Onvexia — Crypto Fundamentals, Sentiment & Onchain Tracking

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral context: it returns 'polarity plus the terms that drove it' and explains the crypto-specific tuning, which goes beyond the structured hints. It also clarifies that the tool does not perform lookups, adding transparency about its scope.

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 adds context in a logical flow. The second sentence includes an illustrative comparison to general models ('wagmi') which, while vivid, is slightly verbose. Overall, every sentence contributes value, and the structure is clear without excessive length.

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

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

For a tool with one parameter and no output schema, the description fully covers what the agent needs: what it does, what input to provide, what it returns (polarity and terms), and its specialization. The lack of an output schema is compensated by the explicit mention of the return contents. No critical information 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?

With a single parameter 'text' and 0% schema description coverage, the description compensates by calling it 'arbitrary text you supply' and clarifying it is not a lookup. This adds some meaning beyond the bare name, but it stops short of specifying format, length limits, or examples. For a simple parameter this is adequate but not thorough.

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 clear verb-resource pair: 'Score any text for crypto sentiment.' It specifies the domain (crypto), the input (arbitrary text), and the tuned nature, making it distinct from the many get_* lookup siblings. No ambiguity about what this tool does.

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

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

The description explicitly states 'Takes arbitrary text you supply — it does not look anything up,' which sets a clear context for when to use it: for analyzing user-provided text rather than querying data. It implies it is not for retrieving stored sentiment, but it does not name an alternative tool like get_aspect_sentiment. Still, the usage boundary is clear enough.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context by explaining what the tool reveals (coverage per chain), which goes beyond the annotations but does not address other aspects like response format or pagination. Given the annotations already handle safety, this is an adequate contribution.

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

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

The description is a single, concise sentence that front-loads the core purpose ('What we index per chain for watched addresses') before elaborating on the key aspects. It is efficient with no wasted words, though it could be slightly more explicit about the exact output shape. Overall, it is well-structured and easy to parse.

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

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

With no parameters and no output schema, the description is the sole source of information about the tool. It clearly communicates what the tool provides but does not specify the return format or how an agent should interpret the response. For a simple informational tool, this may be sufficient, but more detail on the output structure would improve completeness.

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

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

The tool has zero parameters, so the baseline for this dimension is 4. The description does not need to explain parameter semantics because there are none. The schema coverage is 100% (vacuously true with no properties), and the description adds no parameter-related information, which 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 clearly states the tool's purpose: to explain what data is indexed per chain for watched addresses, including coverage gaps and the meaning of empty feeds. It names the resource (addresses) and the action (getting coverage info), which distinguishes it from related coverage tools like get_chain_coverage or get_data_coverage. However, it does not explicitly contrast with those siblings, so it doesn't fully exploit 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 implies when to use the tool: when you need to understand coverage for watched addresses, especially when an empty feed might be misinterpreted. It does not provide explicit exclusions or alternatives, but the context is sufficient for an agent to infer appropriate usage. The 'what an empty feed actually means' phrase hints at a troubleshooting scenario.

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 annotations already declaring readOnly, openWorld, idempotent, and non-destructive behavior, the description still adds critical behavioral context: below the observed USD floor, movement is invisible to the tool. This warns about false negatives and the meaning of empty results, which is exactly the kind of detail the structured fields cannot express.

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

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

The description is two short sentences with no filler, and the core subject 'Events on watched addresses' is front-loaded. The second sentence earns its place by explaining a non-obvious data limitation and referencing the correct companion tool.

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

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

For a simple one-optional-parameter read-only tool, the description covers the key non-obvious gap: the USD floor and the need to check coverage. It is slightly incomplete because there is no output schema and the description does not clarify what an 'event' contains or how addresses become 'watched', but the core calling risk is well addressed.

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

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

Schema description coverage is 0% for the single 'limit' parameterwing, and the description does not mention it at all. Although the parameter name and default are partially self-explanatory, the rubric requires the description to compensate when coverage is low; it does not, leaving the parameter's meaning and effect entirely to inference.

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

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

The phrase 'Events on watched addresses' identifies the resource and scope clearly, and the title 'On-chain · Address events' reinforces it. It distinguishes itself from siblings like get_address_coverage by focusing on event data rather than coverage, though it remains an elliptical noun phrase rather than an explicit imperative sentence.

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 get_address_coverage and instructs the agent to check it before interpreting an empty result as silence, which is a concrete when-to-call rule. It does not, however, provide broader selection criteria versus other on-chain or event-related siblings beyond this caveat.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds a useful behavioral nuance beyond annotations: a stream flagged as stale is still served, only old. It also frames findings as 'currently' relevant, suggesting a live snapshot. No contradiction with annotations.

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

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

Two sentences convey the subject, concrete examples, and an important caveat without filler. The practical warning is front-loaded after the summary and 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 simple read-only listing tool with one optional limit parameter, the description, annotations, and schema together tell an agent what it does, why to call it, and how to interpret stale findings. No output schema is present, but none is needed for correct invocation.

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

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

There is one optional parameter, limit, with default 50, and the schema contains no description for it. The description does not mention limit at all, so it adds no parameter-level meaning. The parameter is self-explanatory from its name and default, which keeps this adequate rather than severely deficient.

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 explains what the tool exposes: complaints from the platform's own monitoring agents, itemized as dead collectors, stale data streams, and coverage drops. This identifies the resource and scope clearly, though it uses a noun phrase rather than an explicit verb like 'returns' or 'lists'.

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 trigger: 'Worth checking before relying on a number,' and clarifies that a stale finding does not mean the stream is unavailable—just outdated. It does not name specific alternative tools or exclusion criteria, but the guidance is actionable.

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

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

The annotations already mark the tool as readOnly, idempotent, and non-destructive, so the description adds valuable non-obvious semantics: dev_events_30d is null rather than 0 for no_public_repo and unmapped, and attention_without_substance is only set when the state was actually measured. This precisely clarifies edge-case behavior an agent would otherwise misread.

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 question, then delivers a compact state list and a real-world caution. Every sentence earns its place, and the formatting makes the four states easy to parse without excessive verbosity.

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

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

Despite having no output schema, the description documents the important output semantics: states, null behavior, and conditional field population. It does not define what counts as 'attention' or explain the limit parameter, but the core invocation and result interpretation are covered well enough for an agent to use 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?

The only parameter is 'limit', but the description never mentions it flags, bounds, or what it applies to. Schema description coverage is 0%, so the description was expected to compensate for the sparse schema, but it does not. The name and default 40 are mildly inferable, but the definition adds no semantic value for this parameter.

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

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

The description clearly states what the tool evaluates: whether an AI-sector project ships code relative to the attention it gets, and it defines the four possible states. It is domain-specific and conceptually separate from most sibling tools, though it does not explicitly name an alternative.

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

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

The description gives strong interpretive guidance: the 'unmapped' state must never be reported as a project failing to ship, and it provides the RENDER example to reinforce the rule. It does not explicitly say when to use this tool versus a sibling like get_signal_integrity, but the 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds semantic context about aspect disagreement but does not disclose operational behavior such as output format, time range, or data sources. It adds some value beyond annotations but not rich 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 compact and front-loaded with the core capability. The second sentence earns its place by illustrating why aspect-level sentiment mattersasi useful behavioral nuance, and no words are 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?

The tool is simple (one parameter) and the annotations cover safety, so the description does not need much. It explains the purpose, the specific aspects, and the key distinguishing scenario. However, the lack of any parameter format guidance and no output format hints leaves minor but 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?

With schema description coverage at 0% and the only parameter 'asset' left undocumented, the description has the full burden of explaining how to specify the asset. It only implies the resource generally and does not clarify accepted formats (e.g., symbol, address, ID), which is a meaningful gap for a single-parameter tool.

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

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

The description clearly specifies a verb ('Split'), a resource ('an asset's sentiment'), and distinct aspect categories (technology, price, team, community). It also differentiates the tool from aggregate sentiment tools by highlighting that only this tool can discern disagreements across aspects.

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 strong contextual guidance: use this tool when aspect-level breakdown matters and aggregate sentiment is misleading. It does not explicitly name an alternative like analyze_sentiment or state when not to use it, but the 'only this tool' phrasing makes the selection condition 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?

Annotations already declare read-only, idempotent, and non-destructive behavior; the description adds useful scoping: it returns a profile with cross-system identifiers and warns that tickers collide across chains. It does not describe error/ambiguous-symbol handling for get_asset itself, but the sibling redirect covers the main caveat.

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

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

Three sentences with no filler: the first states scope and payload, the second gives the use case, and the third provides the ambiguity caveat and alternative. All content is front-loaded.

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

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

For a single-parameter read-only resource lookup, this is sufficient: it defines the input, the use case, the output fields, and the relevant alternative when ambiguity is possible. No return schema exists, but the description names the main returned components.

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

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

With 0% schema description coverage, the description must carry the parameter meaning. It does so by explaining that the symbol is a ticker, that tickers can collide, and that this tool is the profile-of-record lookup for that ticker. It could add accepted formats or examples, but the single parameter is adequately contextualized.

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

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

The description identifies a concrete deliverable ('core profile by symbol') and itemizes the payload (name, category, CoinGecko id, contract addresses, chains). It also separates itself from resolve_ticker by stating it is the starting point for disambiguating a ticker, so an agent can distinguish it from lookalike sibling tools.

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

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

It gives an explicit trigger ('Start here when you have a ticker and need to be sure which asset it refers to') and names the exact alternative for ambiguous symbols ('resolve_ticker is the tool that says so instead of guessing'). This is clear when-to-use and 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?

Annotations already declare the call read-only and idempotent, and the description adds valuable interpretation semantics beyond that: section states measured/not_held/failed vs not_applicable, the distinction between 'no treasury' and 'could not read it', and the S06 vs S06b revenue split. This is exactly the kind of behavioral context that prevents misinterpretation.

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 front-loads the main purpose and then provides genuinely important caveats. The all-caps warning and revenue split explanation earn their place, though some phrasing 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?

There is no output schema, so the description carries the burden of explaining return semantics; it does cover the most important ones: section states, not_applicable handling, and revenue split. It does not detail the full response shape or grading scale, but the listed components and caveats are sufficient for correct tool selection and interpretation.

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

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

Schema coverage is 0% and the description does not explain what values 'symbol' accepts, whether it is a ticker, asset ID, or address, or provide examples. The only hint is the phrase 'for an asset', which adds minimal meaning beyond the property title. With no schema description, the tool description should compensate but does not.

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 states a specific verb and resource: 'Get the full fundamental brief for an asset' and enumerates its many components, making it distinct from sibling tools like get_asset_scores or get_asset_technicals. The scope is clear and immediately actionable.

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 use when a comprehensive fundamental overview is needed ('in one call') and provides guidance on how to interpret the returned sections. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to route correctly.

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

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

Annotations already communicate that this is read-only, idempotent, non-destructive, and open-world, so the description need not repeat those traits. It does add useful context about the returned data (chains, contract address, decimals), but it doesn't disclose edge-case behavior such as unknown-symbol handling, ordering, or whether unsupported chains are omitted.

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

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

The description is a single sentence with no filler, and the core output content is front-loaded. The only minor structural flaw is that it is phrased as a noun phrase rather than a verb-led sentence, which slightly reduces clarity.

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

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

For a simple one-parameter read tool with rich annotations, the description is mostly adequate. However, with no output schema, it only loosely implies the return shape (a list of chains with address/decimals) and does not mention responses for unknown symbols or empty results, leaving the agent to guess at output structure.

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

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

With 0% schema description coverage, the description must compensate by explaining the 'symbol' parameter. It does so only indirectly by referring to 'an asset', which implies the symbol is the asset identifier. It stops short of specifying the expected format, case sensitivity, or examples, leaving some ambiguity for the agent.

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

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

The description states the tool's output content explicitly: every chain an asset is deployed on, plus contract address and token decimals. It is not a tautology and is distinguishable from siblings like get_asset or get_chain_coverage, though it lacks a direct action verb ('get', 'list'), making it slightly less crisp than a full verb+resource statement.

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

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

The description offers no guidance on when to prefer this tool over alternatives such as get_asset, get_chain_coverage, or get_address_coverage. It neither states use cases, prerequisites, nor exclusions; the agent can only infer from the name and schema that it takes an asset symbol.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive. The description adds context about the nature of the data: it returns changed metrics with old/new values and reasons, which is useful behavioral insight. It does not contradict annotations.

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

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

Two sentences with no waste. The core purpose is front-loaded, and the use case adds value without bloat.

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 read tool with annotations covering safety, the description gives a high-level idea of the return content (old/new values and reasons) and a use case. It does not specify response structure, but without an output schema that's acceptable. It is reasonably 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 0%, so the description must compensate. It only refers to 'this asset' which implies symbol is the asset identifier, but does not explain the expected format (e.g., ticker vs. ID) or provide any details about the parameter. For a single parameter, this is minimal compensation.

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

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

The description clearly states it returns metrics that changed after first publication, with old/new values and reasons. It distinguishes itself from siblings like get_asset (current values) and get_metric_revisions (metric-centric revisions) by focusing on asset-level revisions.

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 a clear use case ('an agent that quoted an earlier number can find out here that it moved') but does not explicitly name alternatives or when not to use. It implies usage when you need to detect changes in an asset's metrics, but lacks exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive semantics. The description adds meaningful interpretive context: it explains the 0-100 Galaxy Score scale, AltRank's '1 is best' orientation, and warns that the composite alone can mislead—agents must inspect component breakdowns to know whether movement was sentiment- or volume-driven. This goes beyond the structured metadata.

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: the first sentence states exactly what the tool returns, the second defines the metrics, and the third delivers a critical caveat. Every sentence earns its place, and the all-caps warning effectively emphasizes the need to read the component breakdown.

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 no output schema and no parameter documentation, so the description carries the full burden. It explains what the metrics mean and that components exist, but it does not describe the component names, the response envelope, or how `symbol` is resolved. This leaves some context that an agent would need in order to fully 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 sole parameter `symbol` has no description in the schema (0% coverage), and the description does not explain the expected format, resolution rules, or allowed values. It only implies the tool is per-asset via 'An asset's'. With such low schema coverage, the description fails to compensate for the missing 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 specifies the resource (an asset's Galaxy Score and AltRank) and the output's core purpose (with the components behind each). This clearly distinguishes it from ranking-focused siblings like get_top_galaxy_scores or get_top_altranks, which serve a different scope.

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

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

No explicit guidance is given about when to choose this tool over alternatives such as get_asset_fundamentals or get_top_altranks. The warning to read components is interpretive, not a usage rule. An agent must infer from the name and sibling list that this is the single-asset score endpoint.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds one behavioral detail: the 'available' field states whether the asset is held. This is useful context beyond the schema. However, it doesn't disclose what 'social signal' means, how it's computed, or what the response structure looks like. With annotations covering safety, a 3 is appropriate.

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 with no waste. The core purpose is front-loaded, and the 'available' field note is a meaningful addition. It's concise and readable, though it could add a bit more parameter context without becoming bloated.

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

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

With no output schema and 0% schema description coverage, the description carries a heavy burden. It explains the basic purpose and one field ('available'), but it doesn't clarify what 'social signal' includes, how to interpret the response, or how the two parameters behave. For a tool with 2 params and no output schema, this is incomplete. An agent would likely need to guess at the response format and parameter semantics.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters (symbol and days). The description mentions 'per-asset' which maps to symbol, and 'over time' which maps to days, but it doesn't explain the expected format of symbol (e.g., ticker vs. name) or the meaning/range of days. The 'available' field is mentioned but not tied to any parameter. This is a clear gap given zero schema coverage.

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: 'Per-asset social signal over time.' This clearly indicates the tool returns social signal data for a single asset over a time range. It doesn't explicitly differentiate from siblings like get_social_posts or get_sentiment_trends, but the 'per-asset' and 'over time' phrasing gives enough specificity to distinguish it from broader social tools.

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

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

The description implies usage context: it's for retrieving social signal for one asset over time. However, it doesn't explicitly state when to use this over alternatives like get_social_posts, get_sentiment_trends, or get_social_dominance. The 'available' field note hints at a use case (checking if the asset is held), but no explicit when/when-not guidance is given.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive hints. The description goes further by explaining that setups are geometric constructs, not forecasts; that levels carry confirmation timeframes and methods; and that status is derived per request. This adds meaningful behavioral context beyond the structured annotations.

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

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

The description is front-loaded with the core output, followed by concise clarifications of meaningful nuances. Each sentence adds value, though a small amount of redundancy exists across the setup explanation and status line. Overall, it remains appropriately compact.

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

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

Given no output schema, the description does a good job explaining the main returned concepts: merged levels, confirmation timeframes, measured_against, price_age_minutes, setup geometry, and status. It stops short of explaining parameter semantics or result format, but the core usage context is sufficiently complete for a read-only analysis tool.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain either parameter. The term 'asset' loosely implies the symbol parameter, and 'limit' is not mentioned at all. The description provides no guidance on how limit affects results or what format symbol should take.

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

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

The description names a specific verb ('Get') and a precise resource: support/resistance levels merged across four timeframes, per-timeframe indicators, and derived setups. This distinguishes it from sibling tools like get_asset_fundamentals and get_ohlcv without requiring 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 intended use case is implied by the content (technical levels and setups), but there is no explicit statement of when to use this tool versus alternatives, nor any exclusions. An agent can infer its purpose from the resource description, but the guidance is not made 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?

Beyond the annotations, the description discloses critical behavioral quirks: bot_probability is NULL, the list is currently empty, and an empty result is not evidence of a clean corpus. It also explains the semantic meaning of coverage fields, which is exactly the type of context that helps an agent avoid misinterpreting results.

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

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

The description is longer than typical but each sentence adds important interpretative guidance. The warning about reading coverage and note first is front-loadedfake, and the repetition about empty lists reinforces a critical caveat, though it could be tightened slightly without losing meaning.

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 tool with no output schema, the description covers the key output fields, the empty-list behavior, and the correct interpretation. There is no obvious missing context that would prevent an agent from invoking or understanding 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 schema coverage is 100%, so there are no parameter semantics to describe. The description appropriately focuses on output interpretation instead of params, satisfying the baseline for parameterless 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 opening sentence clearly identifies the resource and purpose: accounts flagged as automated or coordinated, with behavioral evidence. It is specific enough for an agent to understand the tool's function, but it does not explicitly differentiate from closely related siblings like get_signal_integrity or get_coordinated_campaigns.

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 strong contextual guidance: read coverage and note first, interpret empty lists as 'no scoring has run,' and treat coverage as the honest metric rather than market cleanliness. It does not explicitly name alternatives or exclusion conditions, so it stops a grade short of full 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?

The description adds meaningful behavioral context beyond the annotations by disclosing that attribution is Etherscan-derived, strong on Ethereum, and sparse on other chains. This informs the agent about data quality variations, which annotations do not cover.

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 no waste: the first lists the key coverage dimensions, the second adds a critical caveat. The core concept is front-loaded, and the caveat is placed logically after the list.

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 tool without an output schema, the description adequately summarizes the returned data types and the data-quality limitation. It could be more explicit about the exact response format, but it covers the essential information an agent needs to understand what the tool provides.

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, so schema coverage is trivially 100%. The description does not need to explain parameters, and the baseline for zero-parameter tools is 4. No additional parameter 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?

Clearly states it provides per-chain coverage metrics, listing specific data points: tokens mapped, labelled addresses, whale transactions, and attribution counts. The verb is implied but the resource and scope are explicit. It does not explicitly differentiate from sibling coverage tools like get_data_coverage, but the focus on chains is evident.

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?

Implied usage for obtaining chain-level coverage data, but there is no explicit guidance on when to use this over alternative coverage tools. The caveat about Etherscan-derived attribution provides context but not selection criteria or exclusions.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior, so the safety profile does not need repeating. The description adds one behavioral detail—that the result communicates what was filtered out—though this detail is ambiguous and not elaborated.

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

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

The description is a single efficient sentence with the core noun phrase front-loaded. The trailing clause 'with what was filtered out' earns its place but is slightly ambiguous and could be clearer without adding length.

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

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

For a simple read-only tool with one optional parameter, annotations already carry much of the safety context. Still, the description lacks usage guidance and parameter meaning, and it gives no hint about graph structure or how 'filtered out' is represented.

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

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

Schema description coverage is 0%, and the description never mentions the only parameter (limit) or its default of 150. An agent must rely entirely on the bare schema label 'Limit' to infer the parameter's meaning.

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

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

The description names a specific resource (assets) and a distinctive relationship (co-mention), so an agent can tell this tool is about which assets are discussed together. It does not explicitly contrast with sibling tools such as get_correlation or get_narrative_clusters, but the 'co-mention graph' concept is reasonably self-identifying.

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

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

No sentence states when to use this tool or when to prefer an alternative. The sibling list is large and none are referenced, so routing depends entirely on the implicit meaning of 'co-mention graph' rather than explicit guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations by explaining the exact-text matching rule and its consequences: it catches copypasta but misses reworded campaigns. This meaningfully informs expectations about result precision.

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 no wasted words. The core function appears first, and the critical matching limitation follows immediately. Every phrase 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 read-only tool, the description is largely sufficient: it states what is detected and how matching works. Because no output schema is provided, a little more detail about the return structure or field contents would make it fully complete, but the current description already covers selection and invocation needs.

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 Registry coverage is 100% by default, and there are no parameters for the description to document. Per the zero-parameter baseline, the description is not expected to add parameter semantics, so a score of 4 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 clearly identifies the tool's subject as 'coordinated posting campaigns' and specifies the exact-text matching mechanism, which makes the function concrete. It stops short of an explicit verb like 'Returns' or 'Fetches', and it does not name sibling tools, so differentiation relies on the semantic content rather than a direct comparison.

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

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

There is no guidance on when this tool should be used instead of related tools such as get_signal_integrity, get_social_posts, or get_similar_posts. The exact-text caveat implies a limitation, but it does not explicitly state the conditions under which an agent should choose this tool over 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?

The annotations already cover read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context: the coefficient is window-based, measures co-movement, and makes no causal or lead/lag claim. It does not describe the output shape or window details, and 'with the lead/lag' creates some potential confusion, so it is not a perfect 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 short and front-loaded: the core purpose appears first, followed by the caveat and sibling routing. Every sentence contributes value and the length is appropriate. The slight ambiguity around 'with the lead/lag' keeps it from being 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?

For a one-parameter read-only endpoint, the description gives the core purpose, causality caveat, and the correct alternative tool, while annotations cover the safety profile. However, with no output schema and no parameter guidance, it leaves the output object shape, window definition, and symbol format unspecified, so the description is not fully self-contained.

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, symbol, has 0% schema description coverage. The description never explains what symbol formats are accepted or provides an example, so it does not compensate for the schema's silence. The phrase 'an asset's social activity' weakly implies symbol identifies an asset, but that is not enough to give the agent concrete parameter guidance.

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

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

The first sentence clearly identifies the tool's resource and question: how closely an asset's social activity tracks its price. It also distinguishes itself from get_leading_indicators by stating that the correlation does not say which series moved first. However, it lacks a direct command verb like 'computes' or 'returns', and the phrase 'with the lead/lag' is slightly ambiguous given the later disclaimer.

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 says the endpoint does not claim causation and does not say which moved first, then directs the agent to use get_leading_indicators for that question. This is a clear when-not-to-use statement with an explicit named alternative. The positive use case, measuring co-movement over a window, is also implied clearly by the first sentence.

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

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

Annotations already mark the tool read-only, open-world, idempotent, and non-destructive. The description adds a valuable behavioral nuance beyond those annotations: absent creators are not ranked low but omitted because they are not ingested, so absence is a coverage fact. This is a meaningful semantic warning that helps an agent interpret results correctly.

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 well structured: the core purpose is front-loaded in the first sentence, followed by a succinct sibling contrast, then an important interpretive caveat. 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 the tool's simplicity, the rich annotations, and the explicit ranking semantics, the description covers the most important behavioral context. Minor gaps remain: no indication of the response shape or how the optional limit parameter behaves, but these are not critical for a straightforward read-only ranking tool.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters, but it never mentions 'limit' or how it affects the returned rankings. The parameter is simple and self-explanatory from its name and default, but the description still adds no 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 opens with 'Rank social creators across the whole corpus by measured influence,' which names a specific verb, resource, and scope. It explicitly distinguishes itself from get_influencers, which is scoped to one asset, making the tool's identity immediately 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 explicitly says it is corpus-wide and contrasts with get_influencers, which is scoped to one asset. This gives an agent a direct condition for choosing this tool over a key 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context by explaining the tool reports the platform's current data holdings and includes freshness timestamps, which aligns with the openWorldHint. No contradiction and no hidden side effects are implied.

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, front-loads the data categories, and includes a practical call-to-action in the final sentence. Every sentence contributes meaning without redundancy.

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

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

Given the tool has no parameters, rich safety annotations, and a clear list of returned coverage dimensions, the description is complete enough for an agent to know when and why to invoke it. No output schema is present, but the description enumerates the key content adequately.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain inputs and, consistent with the empty schema, implies this is a global snapshot that takes no arguments.

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

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

The description clearly states what the tool returns: a platform-wide summary of asset count, priced assets, chains, labelled addresses, social corpus size, and freshness timestamps. It also gives the functional purpose ('check whether an answer is supportable'), which distinguishes it from sibling coverage tools like get_chain_coverage and get_address_coverage.

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 says when to call it: before asserting whether an answer is supportable. It does not mention exclusions or alternatives, but the use context is clear enough for an agent to distinguish this global coverage check from more specific 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description goes far beyond these by explaining critical interpretation rules: null severity means found but not assessed, name_unverified may indicate a different company, and empty results are not statements about never-searched subjects. These are essential behavioral details that prevent misreporting and are not captured in structured fields.

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

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

The description is moderately long with a clear structure: a concise opening sentence, a historical anecdote that provides context, then two highlighted warnings, and a final note. The warnings are appropriately emphasized, but the historical paragraph adds length without direct operational value. It is not overly verbose, but it could be more concise while retaining the critical warnings.

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

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

For a read-only tool with two simple params and no output schema, the description covers the most critical interpretation nuances (null severity, name_unverified, empty results). It also mentions fields like severity and match_confidence, giving some output semantics. It lacks explicit mention of pagination or the exact output structure, but given the tool's safety profile and the richness of behavioral guidance, it is reasonably complete for an agent to call 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 has 0% description coverage for the two parameters (limit, symbol). The description does not mention either parameter, leaving the agent to infer their meaning from names and defaults. Symbol is likely a ticker, but the description doesn't clarify its role in filtering issuers, nor does it explain the limit behavior. Since schema coverage is zero, the description should compensate, but it adds no 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 states the tool retrieves public-record documents (SEC filings and federal court dockets) about tracked issuers. This is a clear verb+resource statement. It doesn't explicitly contrast with siblings like get_asset_fundamentals, but the focus on public records and dockets is distinct enough. The title 'Public disclosures' reinforces the purpose.

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

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

The description provides rich context about why the tool exists (RWA failures) and how to interpret results, but it does not explicitly state when to use this tool versus alternatives. There is no 'use this instead of X' guidance, and no mention of prerequisites or conditions that would select this tool over other get_* tools. The usage is implied by the tool's purpose but not directly stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description adds value beyond those by explaining that the floor is returned in the response and is load-bearing—affecting result size and quality. This warns about rug risks and noise, which is useful behavioral context not covered by annotations.

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

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

The description is concise—two short paragraphs—with every sentence contributing value. The core purpose is front-loaded, and the explanatory detail on the floor parameter is directly relevant 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 single-parameter tool with no output schema, the description is complete. It tells the agent what the tool returns (newly created DEX pairs), how the parameter influences results, and the tradeoffs involved. Nothing essential for correct invocation is missing.

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

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

Despite 0% schema coverage, the description provides deep semantic meaning for the only parameter, min_liquidity_usd. It explains that the floor is the key filter separating signals from scams, and raising it shrinks results while improving quality. This goes well beyond the schema's default 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 clearly states the tool returns newly created DEX pairs filtered by a USD liquidity floor. The verb 'get' and resource 'emerging DEX pairs' are specific, and the condition distinguishes it from sibling market tools like get_asset or get_exchange_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 implies use for discovering emerging DEX pairs and explains the floor's role, but it does not explicitly state when to use this tool versus alternatives or when not to use it. There is no mention of exclusions or alternative 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds meaningful context about the data source (social documents) and output semantics (entities mentioned alongside the asset), going beyond annotation defaults without contradicting them.

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

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

Two concise sentences with no fluff: the first defines the data, the second states the intended use. Information is front-loaded and every clause earns its place.

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

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

For a single-parameter read-only tool with no output schema, the description covers purpose, data source, and output content. Minor gaps remain (return format, asset identifier handling, pagination), but annotations fill the safety profile and the definition is sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly defines the `asset` parameter via 'about an asset' and 'mentioned alongside it', but gives no concrete format, example, or constraints (e.g., ticker vs. name), leaving the agent to infer acceptable values.

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 (extracted) and resource (named entities from social documents about an asset), enumerates entity types (people, organisations, products, tickers), and clarifies its unique value ('find what a narrative is actually about'). This distinguishes it from sibling sentiment and post 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 clearly indicates when to use the tool ('Use it to find what a narrative is actually about'), giving a concrete use case. It does not explicitly name alternative tools or exclusions, but the purpose is specific enough to route an agent correctly among the many siblings.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive, so safety is covered. The description adds the exchange-pressure interpretation, but it does not disclose return shape, pagination, or window limits. This is adequate but not rich 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?

Two sentences, the first states the core purpose and the second adds domain interpretation. No filler or redundant restatement of the title/schema.

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

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

The description is too sparse for an AI agent to fully understand the output or call parameters: there is no output schema, no explanation of the time-window bounds or how limit behaves, and no definition of a labelled entity. The safe annotations lower the risk but do not complete the picture.

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?

Both parameters have no schema descriptions (0% coverage) and the tool description does not explain 'hours' or 'limit'. 'Over the window' only weakly maps to hours, and limit is entirely unaddressed, so the description fails to compensate for the schema gap.

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

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

The description names a specific resource ('labelled entity') and measure ('whale flow') over a window, with a precise semantic mapping of inflows and outflows. This scope separates it from siblings such as get_exchange_flows and get_whale_transactions without needing to open those tools.

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

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

There is no guidance on when to prefer this tool over alternatives or any exclusions. Although the inflow/outflow interpretation implies a use case for distribution/accumulation analysis, no sibling alternatives or conditions 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?

Annotations already establish this as a read-only, idempotent operation. The description adds valuable behavioral context by warning that a single large transfer may be an exchange rebalancing its own wallets, not a genuine distribution or accumulation signal. This goes beyond the annotations and helps the agent interpret results correctly.

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 definition, followed by concise interpretive context and a caution. Every sentence adds value, and 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?

The conceptual semantics are well explained, and the warning about rebalancing is useful. Still, with no output schema and no mention of the symbol parameter or expected return shape, the description is not fully complete for an agent to invoke the tool with confidence.

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

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

Schema description coverage is 0%, and the description never mentions the 'symbol' parameter, its format, or behavior when omitted or null. Saying 'of an asset' only implicitly references the parameter, which is insufficient to compensate for the lack of schema documentation.

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

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

The description states a clear verb and resource: reporting the net movement of an asset into and out of exchange wallets. It adds meaningful definitions of inflows and outflows, but it does not distinguish this tool from the closely named sibling get_exchange_netflow, so it falls short of full 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 provides useful context about when to trust the conventional distribution/accumulation reading and explicitly advises checking get_entity_flows before attributing intent. However, it gives no guidance on when to use this tool versus get_exchange_netflow, which appears to be a near-duplicate based on name alone.

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

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

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds helpful semantic context ('A listing is an ATTENTION event, not a fundamental one') that informs how the agent should weight the data, going beyond the structured annotations.

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

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

The description is three tight sentences with no filler. The core purpose is front-loaded, and the additional sentences about attention events and usage earn their place by providing actionable interpretation guidance.

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

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

For a simple read-only list endpoint with one optional parameter, the description gives enough context to invoke it correctly: what it returns, when to use it, and what not to use it for. It lacks details about time windows or ordering, but the default limit and the straightforward return type keep this from being a major 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 0%, and the description does not explain the 'limit' parameter at all. Although the parameter name and default are self-explanatory, the description fails to add meaning such as how limit affects recency or count, which it should compensate for given the 0% schema coverage.

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 exactly what the tool returns: 'Recent exchange listing announcements — an asset being added to a venue.' It uses a specific verb and resource and clearly distinguishes this from siblings like get_exchange_flows and get_exchange_netflow by focusing on listing announcements rather than fund 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 description provides explicit when-to-use and when-not-to-use guidance: 'Use it to explain a volume or social spike, not as a valuation input.' It also frames listings as attention events rather than fundamental ones, which tells the agent how to interpret and apply the data.

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

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

Annotations already establish the tool as read-only, idempotent, and non-destructive, so the description's burden is lighter. It adds useful semantic behavior: the net_usd field is only present when the token can be priced, which is a meaningful caveat. It does not disclose pagination, rate limits, or response shape, but those are not critical given the annotations.

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

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

The description is three short sentences that pack the core meaning and an interpretive note with minimal waste. It is front-loaded with the primary subject and uses no filler.

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

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

For a simple read-only tool with one optional parameter, the description covers the core semantics but omits important details like the response format, time horizon, and the effect of limit. Without an output schema, these gaps make the description only partially 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 only parameter, limit, is entirely undocumented in both the schema and the description. The description adds nothing about how limit affects results (e.g., number of tokens returned). Since schema coverage is 0%, the description fails to compensate for the missing 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 identifies the resource (exchange netflow), the granularity (per-token), and key metrics (flow, net_usd). It clearly states what the tool does, though it doesn't explicitly distinguish it from the similarly named sibling get_exchange_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 provides no guidance on when to use this tool versus alternatives, nor any context about use cases or prerequisites. The interpretation of inflow/outflow hints at analytical uses, but there is no explicit 'use this when...' or mention of 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds the temporal dimension and cohort interpretation, but does not disclose output shape, limit handling, or data frequency. There is no contradiction with annotations.

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

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

Single sentence, clear and front-loaded, with no filler. It is minimal but appropriately compact for a simple read-only metric tool.

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

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

For a tool with no output schema and a single undocumented parameter, the description leaves the meaning of limit ambiguous and does not specify the returned time-series format. However, the core concept is conveyed and annotations cover safety.

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

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

Schema description coverage is 0%; the description never mentions 'limit', and the schema only provides a default and type. An agent cannot infer whether limit refers to time periods, data points, or something else. The description adds no parameter-level meaning.

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

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

The description names the exact resource (Bitcoin supply segmented by coin-age cohorts) and the analytical purpose (holding vs moving). This uniquely identifies HODL waves among many sibling metric tools without requiring schema inspection.

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

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

No guidance is given about when to use this tool versus alternatives, nor any mention of asset scope or comparison to other on-chain metrics. Usage context is only implied by the metric name and title.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering safety. The description adds valuable behavioral context about the ranking methodology (accuracy vs loudness, Predictor vs Reactor), which goes beyond the annotations. It does not describe output format or pagination, but for a no-parameter tool this is acceptable. No contradictions with annotations.

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

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

The description is two short paragraphs and is front-loaded with the core purpose. The second paragraph explains the scoring axis without unnecessary fluff. It is concise and each sentence contributes to understanding. No redundant repetition of the tool name or schema.

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

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

With no parameters and no output schema, the description carries the full burden of explaining what the tool returns. It explains the ranking philosophy and the Predictor vs Reactor axis, but does not describe the shape of the output (e.g., list of entries with fields). Since it's a leaderboard, an agent might reasonably expect an array, but the structure is not specified. This is a minor gap, but the description is adequate for understanding the tool's purpose.

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 schema coverage is 100% (empty properties). Per the rubric, a zero-parameter tool gets a baseline of 4. The description does not need to explain parameters, and it doesn't introduce any confusion. It correctly omits parameter details because there are none.

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 this tool returns a leaderboard of influencers ranked by accuracy ('what people actually got RIGHT') rather than by popularity. It defines the resource and the specific ranking criterion, and the Predictor vs Reactor scoring is a distinctive feature. It doesn't explicitly name sibling tools like get_creator_rankings or get_influencer_ledger, but the purpose is specific enough to differentiate implicitly.

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 this tool (when you want accuracy-based rankings rather than reach-based ones) but does not explicitly state use cases or exclusions. No alternatives are named, and there is no guidance on when NOT to use it. The context is implied through the differentiator, but explicit routing is missing.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds value beyond these by explaining the conceptual meaning of the ledger (Predictor/Reactor) and the data it contains (hit rate, track record). This is useful context not present in annotations.

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

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

Two concise sentences with no filler. The primary purpose is front-loaded, and the second sentence clarifies the concept without redundancy. Every word 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 simple read-only tool with one parameter and no output schema, the description covers the core meaning and data components (hit rate, track record). It does not specify the exact output structure, but the mention of included elements gives a sufficient hint. Given the low complexity, this is reasonably 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 description coverage is 0%, so the description must compensate. The description does not explicitly mention influencer_id, but the tool name and phrasing 'an influencer's' make the parameter self-evident. However, it adds no format, constraints, or nuance beyond what the schema type (string) implies, so it only marginally compensates.

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

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

The description states a specific verb ('Get'), a clear resource ('an influencer's accountability record'), and defines the unique output (Predictor vs Reactor, hit rate, track record). This clearly distinguishes it from siblings like get_influencer_leaderboard and get_influencers, which serve different purposes.

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 it (when you need an influencer's accountability record), but it does not explicitly state alternatives or exclusion criteria. There is no mention of when to prefer get_influencer_leaderboard or get_influencers, so guidance is implied 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: ranking is by measured activity in the corpus, not follower count or correctness, and a large account posting noise ranks here. This clarifies the tool's behavior beyond the annotations. It doesn't describe pagination or return format, but with annotations covering safety, a 4 is appropriate.

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 with zero waste. The core purpose is front-loaded in the first sentence, and the second and third sentences add crucial differentiation and behavioral context. 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?

For a simple one-parameter read-only tool with rich annotations, the description is nearly complete. It explains the ranking logic, the distinction from the ledger tool, and the safety profile is covered by annotations. The only gap is the exact format of the 'asset' parameter and the return structure, but with no output schema and a single parameter, the description does enough. A 4 is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate. The description implies the 'asset' parameter is the asset whose conversation is being analyzed ('The accounts driving conversation about one asset'), which adds meaning beyond the bare schema. However, it doesn't specify the format or allowed values for 'asset' (e.g., ticker vs address vs name), so it doesn't fully compensate. With one parameter and clear contextual meaning, a 4 is justified.

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

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

The description states a specific verb ('get'), a resource ('influencers'), and a scope ('by asset'), and explicitly distinguishes it from get_influencer_ledger. It clearly defines what the tool does: rank accounts driving conversation about one asset by reach and engagement. The title 'Social · Influencers by asset' reinforces the resource and scope.

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 says when to use this tool vs alternatives: 'see get_influencer_ledger for track record' and 'that is the point of keeping the two tools separate.' It also clarifies what this tool is NOT (not by follower count, not by correctness), which helps an agent select it appropriately. This is explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: the response is an observed ordering of two series, not a forecast, and it can break. This goes beyond the annotations and helps set expectations about the output's meaning and limitations.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second adds the critical caveat and sibling distinction. Every sentence earns its place, and there is no redundant repetition of the title or schema.

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

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

For a single-parameter read-only tool with rich annotations, the description is nearly complete. It explains what the tool does, what it does not do, and the key limitation of the output. The only minor gap is that it does not explicitly state the expected format of the 'symbol' parameter, but the schema and the tool's name make this inferable.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. The description implies the tool operates on an asset ('for an asset'), which maps to the required 'symbol' parameter, but it does not explicitly state that 'symbol' is the asset identifier or provide format details. With only one required parameter and a clear implication, 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 ('get') and resource ('leading indicators'), and immediately clarifies the scope: social and on-chain signals that have historically moved first for an asset. It also explicitly distinguishes itself from get_correlation, which helps an agent differentiate between the two tools 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?

The description explicitly names get_correlation as the sibling that does not answer the lead/lag question, and clarifies that this tool is the one that does. It also warns that a lead measured over a past window is not a forecast, which is a clear usage caveat. This is strong when-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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety. The description adds useful behavioral context: it clarifies that the tool provides resolution granularity and discloses approximation caveats, which is beyond the annotation coverage. No 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?

Three sentences, front-loaded with the core purpose, followed by a precise usage directive and a brief explanation of two key fields. No filler or repetition.

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 tool, the description provides sufficient information: what it returns, when to use it, and why. It does not detail the exact metric identifier format, but that is a minor gap given the tool's simplicity and the clarity of the purpose.

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

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

Schema description coverage is 0%, so the description carries the burden. It refers to 'one metric' but does not explicitly define the format or domain of the 'metric' parameter (e.g., a metric ID or name). While the tool name and context make it reasonably inferable, the description could be more explicit about what value to pass.

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 and resource: 'Describe one metric' and lists the specific fields it returns (parity, category, minimum interval, caveat). It distinguishes itself from the sibling get_metric_timeseries by being the prerequisite call, so an agent can tell them apart immediately.

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 instructs 'CALL THIS BEFORE get_metric_timeseries if the metric is unfamiliar', naming the exact sibling and the condition for use. It also explains why (minimum interval and caveat), leaving no ambiguity about when to invoke it.

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

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

Annotations already convey read-only, idempotent, and non-destructive behavior, so the description's burden is lower. It adds useful context about the content (restatements, period, rationale) and a behavioral caveat (corrections are not market moves). It does not mention ordering, pagination, or the effect of the limit parameter, but this is acceptable given the annotations.

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

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

The description is two short sentences with no filler. The leading noun phrase 'Restatements of published numbers' is immediately informative, and the second sentence earns its place as a meaningful caveat. It is a model of concise, front-loaded writing.

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 read-only tool, the description gives a reasonable high-level sense of the returned content. However, with no output schema, details about the response shape, ordering, and how the limit parameter affects the result are absent. The description is adequate but leaves an agent guessing about the exact return structure and pagination behavior.

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

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

The only parameter, limit, has 0% schema description coverage, and the description does not mention it. This leaves the agent to infer that limit caps the number of returned revisions, with no information about maximum values, default behavior beyond the schema default, or how it affects results. The description fails to compensate for the schema's lack of documentation.

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

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

The description clearly identifies the resource (restatements of published metric numbers) and the core question it answers: what changed, over which period, and why. The caveat 'A correction is not a market move' adds useful thematic framing. However, it does not explicitly differentiate from the very similarly named sibling get_asset_revisions, relying on the tool name to carry that distinction.

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

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

No explicit guidance is given about when to choose this tool over alternatives such as get_metric_timeseries or get_asset_revisions. The phrase 'A correction is not a market move' implicitly suggests it should not be used for market-direction signals, but there is no clear statement of intended use cases, exclusions, or alternative 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the behavioral context that this is a batch call returning the latest value for many metrics, and that metrics is comma-separated. It doesn't disclose pagination, response format, or rate limits, but for a read-only batch tool with strong annotations, a 3 is appropriate.

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 no waste. The core purpose is front-loaded, and the comma-separated detail and mirror reference are placed efficiently. 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?

For a simple 2-parameter read-only tool with strong annotations, the description is mostly complete. It tells the agent the key usage pattern (many metrics, one asset, single call) and the comma-separated format. However, it doesn't specify the asset identifier format or the response shape, and with no output schema, an agent might not know what to expect back. The mirror reference helps but doesn't fully resolve this.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that 'metrics' is comma-separated, which adds meaning beyond the schema's bare string type. However, it doesn't explain the format of 'asset' (e.g., ticker, ID, slug) or provide examples. The description adds some value but doesn't fully compensate for the 0% schema coverage.

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

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

The description states a specific verb ('get'), resource ('metrics'), and scope ('MANY metrics for ONE asset in a single call'). It clearly distinguishes itself from the sibling get_metric_timeseries_multi by calling itself the 'mirror' of that tool. However, it doesn't explicitly name the sibling in the description, relying on the sibling list for context, so it's not a full 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 implies when to use this tool: when you need the latest value of many metrics for one asset in a single call. It also references the sibling get_metric_timeseries_multi as its mirror, which hints at the alternative for timeseries data. However, it doesn't explicitly state when NOT to use it or provide a direct comparison with other metric tools like get_metric_timeseries or get_metric_metadata.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false, so the safety profile is clear. The description goes beyond annotations by clarifying the error semantics: 'not available' vs 'no data in range', which prevents misinterpretation. It also mentions date format support, adding value.

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 with no fluff. The most critical information (date formats and error semantics) is front-loaded. Each sentence adds unique value; nothing redundant.

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

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

With 6 parameters and no output schema, the description covers date format and error behavior but omits what 'metric' and 'asset' accept (e.g., tickers vs slugs), how 'aggregation' works, or the output shape. Since annotations cover safety, the gap is in param semantics and output understanding.

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

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

Schema coverage is 0%, so description must compensate. The description mentions dates but doesn't explain the meaning of 'metric','asset','interval','aggregation' beyond names. The error semantics add some context but not full parameter guidance.

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

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

The description clearly states it returns timeseries data for a metric on an asset. It is distinct from siblings like get_metric_metadata and get_metrics_batch, though it doesn't explicitly differentiate. The verb 'get' and resource 'metric timeseries' are specific.

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 retrieving metric timeseries but doesn't explicitly specify when to use this over get_metric_timeseries_multi or get_ohlcv. It notes relative and ISO dates, which is helpful but not a full when/why.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds useful context: the single-call efficiency and the guarantee that values come from the same read (consistency). This goes beyond what annotations provide, though it doesn't mention rate limits or pagination.

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 zero waste. The purpose is front-loaded, followed by a clear usage recommendation. 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 5 parameters and 0% schema coverage, the description is incomplete. It covers the assets format and the tool's advantage over the sibling, but omits explanation of metric, date formats, and interval options. Since the agent must rely on the description to fill schema gaps, this leaves ambiguity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the assets parameter format (comma-separated) but does not explain metric, from_date, to_date, or interval formats or semantics. The date defaults and interval are left entirely to the schema, which has no descriptions. This is a significant gap for required parameters beyond assets.

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 the tool fetches timeseries for ONE metric across MANY assets in a single call. The verb 'get' and resource 'timeseries' are specific, and it explicitly distinguishes itself from the sibling get_metric_timeseries by noting the multi-asset scope.

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 guidance: 'Prefer this over looping get_metric_timeseries' with a concrete reason (one round trip instead of N, and guaranteed same read). This tells the agent exactly when to use this tool versus the 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?

Annotations already carry safety (readOnlyHint=true, idempotentHint=true, destructiveHint=false) and openWorldHint=true. The description adds genuinely useful behavioral context beyond that: the >=2 distinct authors constraint and the exclusion of copypasta/near-identical posts from one account. This meaningfully shapes what an agent should expect in the result set.

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 no filler. The defining scope ('raw clusters... without the prose') is front-loaded, and the critical data-quality filter (copypasta exclusion) is the only secondary detail. Every clause earns its place.

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

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

For a one-optional-parameter, read-only tool with safety covered by annotations, the description is nearly complete: it defines the data semantics and the inclusion/exclusion rule. The only gaps are explainability of 'limit' and the absence of any return-shape hint, which is softened by having no output schema to reference.

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

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

Schema description coverage is 0%, so the description must compensate, but it never mentions the single 'limit' parameter — how it bounds results, whether it truncates, or how clustering count relates to it. While the name/default make it partly self-evident, the description adds zero parameter-level meaning.

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

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

States a specific verb+resource ('raw clusters behind the stories') and an explicit consumer ('for a model doing its own summarisation'). The phrase 'without the prose' differentiates it from prose-returning siblings like get_story_posts and get_trending_stories, so an agent can pick it 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?

The description gives a clear intended context — raw cluster data for a model that will do its own summarisation — which implies when to choose this over prose-bearing siblings. It stops short of explicitly naming alternatives or stating when-not-to-use, leaving the sibling routing slightly 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?

Beyond the read-only annotations, the description discloses two important behaviors: the `vocabulary_stale` artifact that can manufacture false rotation signals, and the semantics of `unconfirmed: true` where confirmation is absent rather than zero. These interpretive caveats are exactly the kind of context annotations cannot express.

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

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

The description is front-loaded with the core purpose, then organized into focused paragraphs for scope, the vocabulary caveat, and the unconfirmed-confirmation caveat. There is no filler, repetition, or restating of annotations.

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

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

For a read-only tool with two optional parameters, the description covers windowing logic, coverage scope, and critical output-field caveats, while annotations cover safety. The main gap is the unexplained `include_legacy` parameter and the lack of any response envelope detail, but the core invocation contract is sufficiently clear.

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

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

Schema description coverage is 0%, so the description must explain parameters. It clarifies `days` by defining the equal-length prior window comparison, but `include_legacy` is never tied to a concrete meaning, leaving the agent to guess what legacy narratives are included or excluded.

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 opening sentence states a specific, measurable purpose: identifying which crypto narratives are gaining or losing attention share with a liquidity confirmation leg. It further defines the comparison-window method and the covered narrative set, making it clearly distinct from siblings like get_narrative_clusters or get_social_dominance.

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

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

No guidance is given on when to choose this tool over related narrative, sentiment, or social-dominance tools. The only strong usage advice, reading `vocabulary_stale` before quoting deltas, affects interpretation of results rather than tool selection.

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

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

Annotations already declare readOnly, idempotent, openWorld hints; the description adds valuable behavioral nuance: the coverage limitation (only USDT pairs on Binance/Bybit) and clarifies that absence is about data source, not price existence. This goes beyond repeated annotations and helps set expectations about data availability.

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 the core function front-loaded and the coverage caveat placed second. It is efficient and to the point, though the second sentence is a bit long and could be split without loss.

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

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

With no output schema, the description should mention return format or structure; it doesn't. However, it does clarify coverage and venue, which are key for correct interpretation. Missing parameter details (limit) and return format make it only partially complete. For a simple read tool, it's adequate but leaves the agent to infer common behavior.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It mentions 'for an asset' implicitly covering 'symbol', but does not explain 'limit' at all. The description adds minimal value beyond what the schema provides (which only has names and defaults). For a tool with zero coverage, this is a significant gap.

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

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

The description clearly states the tool returns daily OHLCV candles for an asset, and adds the venue from which they came. It's specific about the resource (asset) and data type, and distinguishes it from generic time-series tools by mentioning candle granularity and venue.

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 coverage constraint (assets with USDT pair on Binance/Bybit) and explains that absence doesn't mean no price, but it doesn't explicitly mention when to use this tool versus alternatives like get_metric_timeseries. The coverage note implies a selection criterion but doesn't name alternatives or provide 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?

The description adds valuable behavioral context beyond the annotations by disclosing the `unavailable` field and warning about silent omissions in the report. This is a specific, non-obvious behavior an agent should know. With readOnlyHint and idempotentHint already covering safety, this extra context about report completeness earns a 4.

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, both earn their place: the first states the core purpose, and the second explains a crucial output field. The warning about `unavailable` is slightly wordy but remains focused. Front-loaded enough for easy scanning.

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 tool with no output schema and rich annotations, the description is adequate but has gaps. It does not describe the overall report structure or what fields an agent can expect beyond `unavailable`. An agent could call it correctly, but it may not know how to use the returned report without more schema or output 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?

Schema coverage is 0% and the description does not explain the `symbol` parameter at all. It only says 'One asset's,' which is a vague inference rather than explicit guidance on what format symbol should take (e.g., ticker, address). The parameter is left entirely to the schema's type string, adding no meaning.

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

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

The description 'One asset's generated report' clearly identifies the tool as retrieving a single asset's report, distinguishing it from siblings like list_research_reports which presumably list multiple reports. However, it lacks an explicit verb like 'get' or 'fetch' and does not specify what kind of report (e.g., research vs. technical), relying on the title for that 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention that list_research_reports is for browsing available reports or that other metric tools should be used for raw data. The mention of the 'unavailable' field is about interpreting output, not about selecting this tool over others.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the tool's safety profile is covered. The description adds valuable behavioral context beyond annotations: results include sample size and confidence interval, and low-n sentiment is unreliable with concrete error rates. This goes well beyond the structured metadata, though it does not describe output shape or edge cases.

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

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

The description is two sentences, front-loaded with purpose, and the critical reliability warning earns its place. There is no filler or repetition of annotation data.

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

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

For a single-parameter, read-only tool with no output schema, the description explains the core purpose, key output elements (sample size, confidence interval), and a critical interpretation caveat. It is slightly incomplete on asset identifier format and exact response shape, but sufficient for an agent to use 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?

With schema description coverage at 0%, the description must compensate for parameter meaning. It only repeats 'for an asset' without explaining the accepted format, identifier type, or constraints. An agent gets no more semantic detail than the parameter name 'asset' 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 clearly states a specific resource and scope: 'sentiment over time for an asset' with sample size and confidence interval. It does not explicitly differentiate from siblings like analyze_sentiment or get_aspect_sentiment, but the 'over time' qualifier and mention of sample size/CI imply a distinct trend-focused purpose.

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

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

The description provides strong interpretive guidance ('Read n before quoting a direction') but no explicit when-to-use vs alternatives. The phrase 'sentiment over time' implies trend use, but there are no exclusions or references to sibling tools such as analyze_sentiment for point-in-time sentiment.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value beyond this by specifying the 0-100 score range, the three fused components, and an Exit Liquidity Radar flag. It does not contradict annotations and provides meaningful behavioral context about what the score represents.

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

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

The description is highly concise: two short sentences that front-load the purpose, then expand on the components. Every phrase adds value, and there is no redundant or filler content. It earns its place in a compact form.

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

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

With no output schema, the description partially explains the return: a score 0-100 and a flag. However, it does not describe the response structure, the meaning of the Exit Liquidity Radar flag, or how to interpret the score in practical terms. For a tool of moderate conceptual complexity, this is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'symbol' parameter, but it does not mention the parameter at all. It leaves the agent to infer that symbol means the asset ticker, with no format or constraints provided. This is a clear gap given the low coverage.

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

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

The description clearly states a specific verb ('Get'), resource ('Signal Integrity score'), and the conceptual purpose ('is the move real or exit liquidity?'). It differentiates itself from sibling tools by explaining it fuses social authenticity, on-chain reality, and fundamental backing, which is unique among the many get_* tools.

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

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

The description explains what the tool does but provides no guidance on when to use it versus alternatives like get_asset_scores or get_ai_substance. There are no conditions, exclusions, or references to sibling tools, leaving the agent to infer when this score is the right choice.

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

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

The description adds critical behavioral guidance beyond the annotations by warning to read the returned BAND rather than the raw cosine and quantifying the score distribution (43% of the corpus sits at 0.80–0.90 by default). This prevents a common misinterpretation of the output and is genuinely valuable 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?

Two concise sentences: the first states the core action and resource, the second delivers a crucial interpretation warning. Every word earns its place, and the most important usage caution is front-loaded.

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

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

The tool is simple (one parameter, rich annotations, no output schema), and the description covers the essential behavior and output interpretation. It could be slightly more complete by explicitly describing the returned structure beyond 'BAND' and 'raw cosine', but for this complexity level the gap is minor.

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

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

With schema description coverage at 0%, the description must compensate. It minimally clarifies that post_id refers to the 'given post' used as the reference for similarity, but it does not explain how to obtain a valid post_id or what happens for invalid IDs. The schema's type and title already convey the basic meaning, so the added semantic value is modest.

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 ('nearest'), a resource ('posts'), and the method ('embedding space'), making it clear this is a similarity-search tool. It distinguishes itself from siblings like get_social_posts or get_story_posts by emphasizing embedding proximity rather than simple retrieval.

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

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

Usage is implied: use this when you need posts similar to a given post in embedding space. However, it does not explicitly mention alternatives or conditions when this tool should be preferred over sibling retrieval tools, so the 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint:false, covering the safety profile. The description adds useful behavioral context beyond those hints: sentiment may be uncomputable for most assets despite a large corpus total, and documents pile onto BTC. This helps an agent set expectations about sparse coverage.

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

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

The description is compact and front-loaded: it opens with the tool's core purpose, then adds the call-timing rule, then the reason. Every sentence earns its place and there is no filler or repeated schema 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 simple optional-parameter tool with rich annotations, the description covers purpose and usage timing well. However, with no output schema, it does not describe the return shape, and the 'band' parameter is completely unexplained, so an agent cannot fully predict or customize the call.

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

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

The input schema has one parameter, 'band', with a default of 300 and no description, and schema description coverage is 0%. The tool description never mentions 'band', so the agent cannot know what it controls, its units, or how changing it affects the result. With zero compensation from the description, this is a serious gap.

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

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

The description states that the tool measures how many assets clear a document floor that makes social metrics computable, which is more specific than the title alone and points to a coverage-count result. It does not use a crisp imperative like 'returns' or 'lists', and the phrase 'document floor' is left undefined, so it falls short of a 5.

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

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

It gives explicit temporal guidance: 'Call this BEFORE quoting sentiment for an asset.' It also explains why with the power-law/attention argument, which helps an agent decide when coverage matters. It does not explicitly name alternative tools or state when not to use it, so it misses the top score.

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

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

Beyond the readOnlyHint/idempotentHint annotations, the description adds meaningful behavioral nuance: it explains that share sums across the universe and that an asset's dominance can fall while absolute volume rises, and it highlights that distinct authors separates real conversation from spam. This goes beyond structured annotations to explain the metric's behavior and intended interpretation.

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 main purpose is front-loaded in the first sentence, and the additional paragraph is useful context about interpreting the share metric and the distinct authors column. It is fairly concise and every sentence adds value, though the second paragraph is somewhat explanatory rather than strictly operational.

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

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

For a read-only tool with one parameter and no output schema, the description is reasonably complete. It previews the returned data (posts, distinct authors, engagement, sentiment) and explains the core share semantics. However, it doesn't explicitly explain the window parameter or what 'window' means in terms of hours, and it doesn't describe the exact output shape (e.g., rows per asset, time units).

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 one parameter, hours, with 0% schema description coverage, so the description must compensate. However, it only mentions 'over a window' and never explains that the hours parameter defines that window, its default of 168, or valid ranges. The default and type are in the schema, but the description adds no meaning beyond the schema's bare field name.

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

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

The description clearly states the tool returns each asset's share of total social attention over a window, with underlying posts, authors, engagement, and sentiment. It distinguishes this from sibling tools like get_social_posts or analyze_sentiment by emphasizing the relative share metric, not raw posts or standalone sentiment.

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 interpretive guidance about share being relative and the importance of distinct authors, but it never explicitly says when to use this tool versus alternatives. No sibling tools are named, and there are no conditions or prerequisites stated for choosing this over other social-data 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?

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond 'collected' – no pagination, sorting, return shape, or rate limits. It fails to add value beyond what annotations and the tool name already state.

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

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

The description is a single short phrase, front-loading the resource and squeezing the platform filter into a compact, readable form. It has no filler, though it is not a fully articulated sentence.

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

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

For a read-only tool with two optional parameters and no output schema, the description covers the essential resource and the filter. But it omits any indication of return shape, pagination, or time range, and does not position the tool against its many siblings, making it minimally adequate rather than 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 description coverage is 0%, so the description must compensate. It does list valid values for platform (bluesky, farcaster, reddit, 4chan, bitcointalk, rss), which is helpful and not in the schema. However, it provides no explanation of limit or its default behavior, leaving a partial gap.

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

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

The description clearly identifies the resource (collected social posts) and the optional platform filter, listing specific platforms. It is distinct enough from siblings like get_story_posts or get_similar_posts, though it doesn't explicitly contrast with them.

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

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

The description implies usage: retrieve social posts, optionally filtered by platform. However, it gives no explicit when-to-use or alternatives among the large sibling set, so 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?

Annotations already establish this as a read-only, idempotent operation. The description adds meaningful behavioral specifics: it enumerates the full queryable schema, includes rules, and discloses what is deliberately not exposed. It does not mention response format or pagination, but those are minor for a parameterless schema tool.

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

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

The entire description is one front-loaded sentence that conveys scope, association with run_sql, and inclusion of rules/exclusions with no wasted words.

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

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

For a parameterless schema-discovery tool, the description is complete: it states what is returned, the governing rules, and the deliberate exclusions. Combined with rich annotations, an agent has everything needed to invoke 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?

The tool has zero parameters, so there is nothing for the description to document. The schema already fully covers the empty parameter set, and the description appropriately focuses on output scope instead.

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 ('List') and a precise resource ('every relation and column queryable via run_sql'), and further clarifies it includes rules and deliberate exclusions. This clearly distinguishes it from sibling data-retrieval tools by tying it directly to run_sql.

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 it clear that this tool is the schema reference for run_sql, so an agent can infer when to use it. However, it does not explicitly name alternative metadata tools or state when not to use it, leaving a small gap in routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior. The description adds useful context beyond that: it reveals the relationship between stories and their source posts and positions the tool as a verification layer rather than just a data fetch.

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 with no filler. The core definition is front-loaded ('the receipts'), followed immediately by actionable guidance. 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?

For a simple one-parameter read-only tool with comprehensive annotations, the description is complete. It explains what the tool returns, why it exists, and when to use it. No output schema exists, but the return value ('individual posts') is sufficiently self-describing.

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

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

Schema coverage is 0%, so the description carries the burden of explaining the story_id parameter. It does not explicitly name story_id, but 'the individual posts a story was assembled from' makes it evident that the parameter identifies a story whose constituent posts should be returned. For a single obvious integer parameter, this is adequate.

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 individual posts a story was assembled from — the receipts.' This clearly distinguishes it from sibling tools like get_social_posts or get_trending_stories by framing stories as summaries built from these posts.

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 says when to call it: 'Call this whenever a story matters enough to check' and explains it is the way to verify that a summary reflects its sources. It does not name alternatives or when-not-to-use cases, but the usage 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds valuable context on how to interpret AltRank (a rank where 1 is strongest) and explains behavior in falling markets. This goes beyond the annotations, though it doesn't describe output structure or potential caveats like data freshness.

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 core purpose. It efficiently explains the rank concept and provides a pairing suggestion. There's minimal fluff, and each sentence contributes to understanding the tool. It's concise and well-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 simple read-only tool with one parameter, no output schema, and annotations covering safety, the description is mostly complete. It explains the core concept of AltRank and relative standing, and gives a usage hint. It doesn't describe the return format (e.g., list of assets with scores) but that's a minor gap given the simplicity and likely obvious output.

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

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

The schema has a single parameter 'limit' with a default of 10 and type integer, but schema description coverage is 0% because the description never mentions limit. Since coverage is low, the description must compensate, but it doesn't explain the meaning or behavior of limit. While the parameter is self-explanatory, the description fails to add any value for it, so a low score is warranted.

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

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

The description states the tool returns 'the assets ranked best by AltRank right now' and distinguishes relative standing from absolute, which is clear. It doesn't explicitly say it returns a list or top-N, but that's implied. It also doesn't name the resource explicitly beyond 'assets', but that's clear enough. It stands apart from siblings like get_asset_scores by focusing on ranking.

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 suggests pairing with get_asset_scores when the relative vs absolute distinction matters, which gives one alternative. However, it doesn't explicitly state when to use this over other ranking tools like get_top_galaxy_scores or get_trending_assets, nor does it state when not to use it. The guidance is partial.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the burden is lower. The description adds genuinely useful behavioral context beyond that: the score's composite composition and the interpretive caveat that a strong Galaxy Score is not a statement about valuation. It does not disclose the return format or limit behavior, but those gaps are modest given the safety profile is fully annotated.

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

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

Four sentences, with the core purpose front-loaded and zero filler: metric definition, interpretation caveat, and sibling routing each earn their place. Minor redundancy ('composite' followed by 'folded together') and awkward line-break formatting keep it just short of a 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?

For a read-only tool with one optional parameter and no output schema, the description covers the essential context: what is ranked, by what metric, how that metric is composed, what the score means, and where to go for the breakdown. It stops short of stating the exact output shape (e.g., a ranked list of asset identifiers with their scores), which is the one meaningful addition for an agent invoking it.

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

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

Schema description coverage is 0%, and the description never mentions the sole parameter `limit` or its behavior (maximum value, default, pagination). Per the rubric, the description carries the compensation burden at this coverage level and does not fulfill it — though the parameter's meaning is trivially inferable from its name, integer type, and default of 10, which keeps this above a 1.

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

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

The description opens with the exact deliverable — 'the assets with the strongest Galaxy Score right now' — and defines the metric precisely (0-100, composite of social volume, engagement, sentiment, and market health). It explicitly differentiates itself from get_asset_scores by naming it as the tool for the score breakdown, and clarifies what a high score does not mean (cheapness). An agent can identify this tool's output among 60+ siblings without guessing.

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 routes to get_asset_scores for the breakdown and warns that a high score signals attention/health, not valuation, which implicitly excludes valuation-driven use cases. What it does not do is contrast itself with sibling ranking tools such as get_top_altranks or get_trending_assets, leaving when-to-use vs. those to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the ranking is weighted by engagement over the window, and it clarifies that a topic posted about loudly by few accounts does not outrank one discussed widely. This goes beyond the annotations.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, the second explains the ranking methodology, and the third routes to the alternative. Every sentence earns its place with no wasted words.

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

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

For a simple read-only tool with 2 optional parameters and no output schema, the description is nearly complete. It explains what the tool returns (ranked topics), how ranking works, and when to use it. The only minor gap is not explicitly describing the output format, but since there is no output schema, a brief note on return shape would help. Still, the description is strong enough for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. However, the description does not explain the 'hours' or 'limit' parameters beyond what the schema shows (integer, default values). The description's mention of 'over the window' implies hours controls the time window, but it doesn't explicitly map parameters to their semantics. Baseline 3 is appropriate since the schema provides names and defaults but no descriptions.

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

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

The description uses a specific verb ('Rank') and resource ('what the market is TALKING ABOUT — themes and narratives, not assets'), and explicitly distinguishes itself from get_trending_assets. It clearly states the tool's scope and what it is not, making it easy for an agent to differentiate from 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 explicitly says 'Use get_trending_assets for tickers; this is the layer above' — providing a direct alternative and the condition for choosing this tool. It also explains the ranking methodology (mentions weighted by engagement) which helps the agent understand when this tool is appropriate.

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

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

Annotations already mark the tool read-only, idempotent, and non-destructive, so the description only needs to add context. It contributes useful behavioral detail by explaining that the response includes a hype score meant to differentiate genuine moves from noise, which goes beyond the schema and annotations.

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

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

A single, front-loaded sentence earns its place: it states what is returned, the ranking criterion, and the meaning of the included hype score, with no filler or 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 zero parameters, no output schema, and annotations that establish the safety profile, the description is nearly complete for a simple listing tool. It could add specifics on ordering or timeframe, but the tool is simple enough that this is a minor 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?

The input schema has zero parameters, and the rubric assigns a baseline of 4 for no-parameter tools. The description adds no parameter detail, but there are no parameters requiring explanation.

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

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

The description identifies a specific verb and resource ('Assets trending now by social activity') and adds a distinguishing element, the hype score, that separates this from sibling tools like get_trending_stories or get_asset_social_signal. Even without naming alternatives, the social-activity and asset scope sets it apart from the other get_* 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 implies the use case: retrieve currently trending assets ranked by social activity and evaluate them with the hype score. It does not explicitly state when to prefer this over get_trending_stories, get_creator_rankings, or get_asset_social_signal, nor does it provide exclusion criteria.

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

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

The description adds meaningful behavioral context beyond the annotations: narratives are machine-generated summaries, not edited articles, and a high post_count with low author_count may indicate one person repeating themselves. This is exactly the kind of interpretive warning an agent needs and is not derivable from readOnlyHint, openWorldHint, or idempotentHint.

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

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

The description is compact and front-loaded, defining the resource first and then adding a crucial interpretive caveat. Every sentence earns its place, and there is no filler or repetition of schema details.

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 read-only tool, the description provides enough context to call it safely and interpret results sensibly. It implicitly signals that returned stories expose post_count and author_count, though it does not describe the full return shape.

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

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

The only parameter, limit, is a conventional optional integer with a default in the schema, so the description's silence on it creates little ambiguity. However, schema description coverage is 0%, and the description does not compensate by explaining how limit affects the result set.

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

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

The description clearly identifies the resource as current narratives and explains the unit of data: an LLM summary of a cluster of posts, not a single document. It lacks an explicit verb like 'retrieve' but the intent is unmistakable. It partially distinguishes itself from post-level tools like get_story_posts, though it does not name 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 intended use is implied by 'Current narratives' and the caveat about reading author_count before quoting one provides real interpretive guidance. However, it does not explicitly say when to choose this tool over alternatives such as get_narrative_clusters or get_story_posts, nor does it state when not to use it.

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

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

Beyond the readOnly and idempotent annotations, the description adds material behavioral context: counterparty labels are included only where held, and null labels mean 'we have no label', not 'unknown' or 'safe'. This directly addresses a likely misinterpretation of the data.

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

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

The description is concise and front-loaded with the main purpose. The warning occupies only two sentences and every sentence adds meaningful information 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?

The purpose and key interpretation trap are covered well, but with no output schema the description leaves the exact response shape, recency window, and `limit` behavior unstated. It is sufficient for safe invocation but not fully predictive of the returned data.

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 description coverage is 0%, so the description must explain parameter semantics. It explicitly maps 'symbol' to 'filtered to one asset', which is helpful, but `limit` is left entirely implicit without any explanation of its behavior or constraints.

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 concrete deliverable: 'Recent large on-chain transfers, optionally filtered to one asset.' This is a specific verb+resource statement and is clearly distinct from the broader flow and entity tools in the sibling 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?

The description provides clear context for when this tool is relevant and gives a strong caveat about interpreting 'whale' as a size threshold rather than identity. It does not explicitly name alternative tools, but the usage guidance about null labels and exchange transfers is valuable and prevents 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the spread is not free money, each issuer carries its own credit/redemption/transfer restrictions, and the cheapest wrapper is often cheapest for a reason. This goes beyond the annotations and prevents a common misuse. It doesn't describe pagination or return format, but with no output schema and a simple limit param, that's a minor gap.

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

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

The description is well-structured: a clear definition, a concrete example, an explicit exclusion, and a critical caveat. Every sentence earns its place. It's front-loaded with the core concept and ends with the most important usage warning. No 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?

For a read-only list tool with one optional param and no output schema, the description is nearly complete. It explains the concept, the scope, the limitation vs. underlying stock, and the risk of misinterpretation. The only missing piece is what the response looks like (e.g., list of wrappers with spread percentages), but the description's example gives a strong hint. Given the tool's simplicity, this is a high score.

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

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

Schema description coverage is 0%, so the description must compensate. The description doesn't explicitly explain the 'limit' parameter, but the tool is a simple list with a single optional limit param, and the default is 40. The description's focus on the concept rather than the param is acceptable because the param is self-explanatory. However, it could have mentioned that limit controls the number of wrapper pairs returned. Given the low schema coverage, a 4 is fair.

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 computes a cross-wrapper spread for tokenized equities, comparing every issuer that tokenizes the same real company. It clearly distinguishes itself from a comparison against the underlying stock, which is a different tool/feed. The concrete SpaceX example makes the purpose immediately graspable.

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 says when to use this tool: for cross-wrapper comparisons, and explicitly says when NOT to use it: not for comparing against the underlying stock, because that needs a licensed equity feed. It also warns against presenting the spread as arbitrage, which is a clear usage boundary. This is exemplary guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds mild behavioral context by enumerating filter categories, but it does not disclose response format, pagination, limit behavior, or how filters interact. This is acceptable given the strong annotation coverage.

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

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

One sentence with no filler; the main resource and filters are front-loaded. Every clause adds useful information, and the category examples are compact but informative.

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

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

For a simple, read-only, filter-based list tool with strong safety annotations and no output schema, the description covers the essential invocation details. Minor gaps remain: no mention of how to combine filters, whether filters are mutually exclusive, or what the response shape looks like, but these are not critical for a browse operation.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning. It does explain chain, entity, and category, including examples and allowed category values, but it says nothing about the 'limit' parameter, its default, or its acceptable range. This partial compensation earns a mid 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 uses a specific verb ('Browse') and resource ('labelled addresses'), and names the three relevant filter dimensions (chain, entity, category) with concrete category examples. This clearly differentiates it from sibling tools like lookup_address, which targets a single address, and get_entities, which focuses on entity metadata.

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

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

The description conveys clear usage context: it is for browsing a list of labelled addresses, with optional filters. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5, but the intended use case is evident from the filtering language.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context beyond those: it defines the parity values (exact/approximate/unavailable), explains that unavailable metrics are intentionally included, and warns to read caveats before relying on numbers. No contradiction with annotations.

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

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

The description is compact and front-loaded: the main purpose is stated in the first sentence, followed by a terse, well-structured explanation of parity values and the rationale for listing unavailable metrics. Every sentence carries meaning, with no filler or 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?

For a simple list tool with rich annotations and no output schema, the description covers the key semantic output (parity and caveats) and the intentional inclusion of unavailable metrics. However, it omits any guidance on the two parameters, which are undocumented in the schema as well, and it does not describe the result shape or ordering. This leaves moderate gaps for an agent deciding whether and how 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?

Schema description coverage is 0%, so the description must compensate for the two parameters (category, available_only). It does not mention them at all. The parameter names are semantically transparent (category filter, available-only toggle), but no detail is given about valid categories, filtering behavior, or how 'available_only' interacts with the unavailable-metric listing, leaving the agent to guess.

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 action ('List every metric'), a clear resource ('every metric Onvexia knows'), and the distinguishing content ('with its parity and caveats'). This clearly separates it from sibling tools like get_metric_metadata or get_metrics_batch, which fetch details or batches rather than a full catalogue.

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 usage context: 'check here before asserting that Onvexia can answer a question' and notes that unavailable metrics are listed on purpose. It does not explicitly name alternatives or give 'when not to use' exclusions, so not a 5, but the context is clear enough for a self-contained catalogue tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond this by noting that the list 'INCLUDING refusals' – a specific trait of what is returned – and that the items are 'previously compiled', implying they are historical saved screens. No contradiction with annotations.

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

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

The description is two sentences with no filler. It leads with the core purpose (what is listed) and immediately adds the useful detail about refusals, then provides a practical use-case. Every word contributes to understanding the tool.

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

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

For a simple read-only list tool with one optional parameter and annotations covering safety, the description is largely complete. It explains the content and the purpose. The only gap is the lack of any mention of the limit parameter or the return format, but given the simplicity and the read-only nature, this is a minor omission; an agent could still correctly invoke the tool with just this description.

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

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

The schema has a single parameter, limit, with zero description coverage. The description does not mention this parameter at all or explain how it affects results (e.g., limiting the number of screens returned). Since schema coverage is 0%, the description is responsible for compensating, but it fails to do so. The parameter name alone is insufficient for an agent to understand its semantics confidently.

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, specific verb and resource: 'list natural-language screens'. It further specifies the content ('the English somebody wrote and the filter it compiled to, INCLUDING refusals'), which distinguishes it from sibling tools like screen_assets (which likely executes filters) and screener_fields (which lists available fields). The purpose is unmistakable.

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

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

The description provides a clear use case: 'Useful as worked examples of the screener's filter grammar before you write one.' This implies when to use it (when preparing to write a screen) and provides context for how it differs from executing a screen. However, it does not explicitly mention alternatives like screen_assets or screener_fields, nor does it state when not to use it, so it falls short of a 5.

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

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

Annotations already establish readOnlyHint, openWorldHint, idempotentHint, and non-destructiveness. The description adds meaningful behavior beyond those: it returns only the index, not the full reports, and absence from the list means no written coverage, not a negative signal about the asset. This is valuable operational context not encoded in the annotations.

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

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

The description is three compact sentences with the core purpose first, followed by the routing instruction and the coverage caveat. Every sentence earns its place and there is no filler.

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

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

For a zero-parameter list tool with no output schema, the description covers what is returned (index), what is not returned (reports), how to get the full data (get_research_report), and how to interpret absence from the list. This is sufficient for an agent to invoke it correctly without further inference.

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 coverage is 100%, so the baseline of 4 applies. The description adds no parameter-specific detail because none 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 states the specific operation: listing assets that currently have a generated research report available. It also clearly differentiates itself from get_research_report by saying it returns the index, not the report bodies, so an agent can distinguish the two 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?

It explicitly routes the agent to get_research_report with a symbol when the report body is needed, and it explains how to interpret an asset missing from the list as a coverage statement rather than an asset problem. This gives clear when-to-use and when-to-use-alternative guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds crucial behavioral context beyond that: the meaning of `known: false` (no label held, not clean/unflagged) and that output includes source and confidence. This prevents a serious misinterpretation and is exactly the kind of transparency that adds value beyond annotations.

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

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

The description is two sentences, front-loaded with the primary purpose and followed by a critical caveat. Every word earns its place; no filler or redundancy. The important nuance is placed prominently, making it efficient and well-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 the tool has a single parameter, no output schema, and simple annotations, the description covers all essential information: what the tool does, what it returns (source and confidence), and a key semantic warning. An agent has everything needed to call it correctly and interpret the response without additional clarification.

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 has zero description coverage for the 'address' parameter, so the description must compensate. It does mention that the parameter is a blockchain address, which is self-explanatory, but it doesn't provide format specifics (e.g., checksummed, chain) or examples. Since the parameter is simple, this is adequate but not enhanced; a 3 is appropriate for minimal compensation.

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

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

The description clearly states a specific action (identify a blockchain address) with the resource and scope (types of labels like exchange, bridge, DEX, etc.) and what is returned (source and confidence). It differentiates itself from siblings by focusing on label identification, which is distinct from address coverage or events tools.

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

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

The description gives clear context: use this to identify an address and its labels. It doesn't explicitly mention alternatives or when not to use it, but the purpose is so specific that an agent would likely know when to invoke it. No exclusions are stated, which aligns with the 4-level of 'clear context, no exclusions'.

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