AltcoinChasersHQ: Acai crypto research

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

Annotations declare readOnlyHint=false and openWorldHint=true, and the description adds real value on top: it discloses the write side effect ('save the latest evidence'), the return value ('next scheduled check'), and idempotency gating of provider work. This is consistent with the non-read-only annotation and goes beyond it.

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

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

Two tight sentences, front-loaded with the primary action and followed by the caveat. Every clause carries information 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?

An output schema exists, so return values need not be restated, and annotations cover the safety profile. The remaining gap is that the required taskId is never described, which for a single-param tool is the one thing an agent would want clarified.

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 single required parameter taskId has 0% schema description coverage, and the description never explains it – it only refers obliquely to 'an owned monitor'. With a required param undocumented in both places, the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource ('Check an owned monitor') and adds the meaningful scope 'when its poll is due', plus the side effects (save evidence, return next check). It is distinguishable from siblings like list_asset_monitors or create_asset_monitor, though it doesn't explicitly name 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?

Gives clear usage context ('when its poll is due') and an important behavioral caveat ('Repeated calls before due time do not trigger provider work'). However, it names no alternative tool or explicit when-not condition, so routing is implied rather than spelled out.

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

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

Annotations already declare this is a read-only, non-destructive, open-world operation, so the safety profile is covered. The description's added behavioral value is limited because the listed dimensions (liquidity, honeypot flags, etc.) are return-content details that the output schema already documents. It says nothing about rate limits, caching, or behavior when a contract address is invalid or unknown.

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

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

Two tight sentences with the capability first and the usage rule second. Every clause carries information (what is checked, the scope constraint, the timing), and there is no padding.

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 lookup with a full output schema and clear annotations, the description supplies what an agent needs to select and call it. The remaining gap is that it never addresses cross-chain scope beyond the enum, or what happens on an unknown/invalid contract, but those are minor given the structured fields already present.

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

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

Schema description coverage is 0% for both required parameters. The phrase 'one exact contract' usefully signals that the address must be a precise contract address rather than a name or ticker, which is real added meaning. However, the 'chain' parameter and its enum values receive no explanation in either place, so the description only partially compensates for the coverage gap.

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

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

The description names a specific action (rug-pull and token security lookup) and resource (one exact contract), then enumerates what the check covers: liquidity, authority, holder concentration, honeypot and tax flags. This is far more specific than the tool name alone. It doesn't explicitly contrast itself with the closest sibling, get_forensics, which keeps it out of 5 territory.

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: 'Use before buying a new or low-cap token,' which tells the agent exactly when this tool is the right call. It doesn't name alternatives or state when not to use it, but the positive usage condition is unambiguous.

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

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

Annotations only declare the write/open-world safety profile, so the description carries real extra weight here: it discloses that each due check consumes the selected sources' member quotas, that polling is agent-driven, and that the monitor can be stopped. The 'Use a stable requestKey' instruction signals idempotency behavior. Missing: what happens on a duplicate requestKey, quota-exhaustion failures, or any auth requirements.

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

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

Three tight sentences with no filler, and the core purpose plus the quota/polling caveat are front-loaded ahead of the requestKey tip. Dense but readable; nothing is wasted, though the phrasing is terse enough to verge on cryptic in places.

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?

An output schema exists, so return values needn't be described, and the annotations cover the write/open-world safety profile. The description supplies the operationally important context an agent needs (quota cost per check, polling responsibility, stoppability, idempotency key), though failure modes and rate-limit behavior remain unstated for a tool whose cost is explicitly recurring.

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, and it only partially does: requestKey is given meaningful semantics (must be stable, i.e. idempotency key) and 'exact-contract' plus 'sources' loosely imply address and chain. intervalSeconds and the enumeration of supported chains are never addressed in prose, leaving two of four parameters unexplained anywhere.

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

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

States a specific verb (Create) plus a well-qualified resource: a 'persistent owner-scoped exact-contract monitor'. The qualifiers 'persistent' and 'exact-contract' begin to differentiate it from siblings like monitor_asset and check_asset_monitor, but no sibling is named, so the agent must still infer which tool to pick.

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

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

Implies ongoing polling ('the agent controls polling and can stop it') which suggests this is for durable, repeated checks rather than a one-shot, and hints at stop_asset_monitor as the lifecycle partner. However, it never says when to prefer this over monitor_asset or check_asset_monitor, nor any prerequisites such as prior authentication or quota availability.

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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that the feed is 'bounded' and carries 'tiered signals and evidence', which is useful framing, but it never explains what 'bounded' means (result cap? recency window?) or how fresh the signals are. The 'not financial advice' line is a disclaimer rather than behavioral disclosure.

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

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

Three short sentences, front-loaded with the resource, then the use case, then the disclaimer. Nothing is padded or repeated from the 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 zero parameters, an output schema, and full read-only annotations, the description covers most of what an agent needs. The unexplained term 'bounded' and the absence of any note on signal freshness or coverage leave a small gap, but nothing essential is missing for invocation.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly implies the feed is unfiltered/unparameterized ('bounded'), consistent with an empty input schema.

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

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

The description names a specific resource ('Acai's bounded alpha signal feed with tiered signals and evidence'), so an agent knows it returns curated early-stage signals rather than raw market data. It does not, however, differentiate itself from close siblings such as get_alpha_launch, get_alpha_surge, or get_daily_picks, which is the main clarity gap.

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

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

'Use to review early altcoin and memecoin opportunities' gives a clear use context, which is better than nothing. But there is no when-not guidance and no routing advice among the several alpha/picks siblings, so an agent must guess whether this or get_alpha_launch/get_daily_picks is the right call.

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

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

Annotations already declare readOnly, non-destructive, openWorld, so safety is covered. The description adds genuine behavioral context beyond that: the tool is intended for polling and the caller must carry cursor and filter values forward between calls. It stops short of stating cadence, rate limits, or what 'fresh, verified' guarantees.

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

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

Two short sentences, both earning their place, with the purpose front-loaded ahead of the operational note. Minor slippage: it refers to 'nextCursor' while the parameter is named 'cursor', adding a small decoding step.

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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The description covers purpose and the polling contract, though with 0% parameter coverage and no sibling differentiation it leaves a couple of gaps an agent would notice.

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 two bare parameters. It names both (cursor as 'nextCursor', minScore) and clarifies they should be preserved across polls, which implies their pagination/filter roles. It still gives no value format, range, or default for minScore.

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 (Read) and resource (the member's Alpha Launch feed) with qualifying adjectives 'fresh, verified'. It is clear what the tool returns, but it never distinguishes itself from closely-named siblings like get_alpha or get_alpha_surge, so an agent must infer which feed it actually wants.

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 polling instruction ('Preserve nextCursor and minScore when polling') implies this is a repeatedly-invoked feed reader, which is useful invocation guidance. However, there is no explicit when-to-use versus get_alpha/get_alpha_surge, and no condition telling the agent which feed to pick.

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 and destructiveHint=false, so safety is covered. The description adds real context beyond them by disclosing the member-safe redaction policy: private wallet, contributor and diagnostic fields are stripped, which tells the agent what data shape to expect.

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

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

A single front-loaded sentence with no filler; the scope claim comes first and the redaction detail second. The semicolon clause is slightly dense but 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?

Output schema covers the return shape and annotations cover safety, so the description needn't restate those. The remaining gap is sibling disambiguation: an agent picking between get_alpha, get_alpha_launch and this feed gets no guidance from the text.

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

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

The tool takes zero parameters, so the baseline is 4. Nothing parameter-related needs explanation, and the description correctly spends its words elsewhere.

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

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

States a specific verb and resource: 'Read the ... Alpha Surge evidence feed.' The named feed distinguishes it from most siblings, but it never differentiates itself from the near-identical get_alpha and get_alpha_launch, which an agent could easily confuse it with.

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

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

No when-to-use, when-not-to-use, or alternative is given. With three alpha-family siblings (get_alpha, get_alpha_launch, get_alpha_surge), the description leaves the selection decision entirely to inference from the tool name.

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

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

Annotations cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the description isn't obligated to restate them. It adds that there is 'saved evidence' returned alongside status, which is a real behavioral hint. But it omits whether the job must exist, whether reads are idempotent, or whether a completed job retains evidence indefinitely.

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, front-loaded verb-resource, no filler. Slightly terse given a 1-param schema with no other context, but 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?

An output schema exists, so return values needn't be explained, and annotations handle safety. What's missing is the lifecycle context for a durable job: when to poll, what statuses exist, how this pairs with resume_asset_research_job. For a 1-param read tool it's adequate, but the async-job semantics are left implicit.

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 there is one required parameter, taskId, which is a UUID. The description says 'one of your durable research jobs' but never explains that taskId identifies the job, its format, or where it comes from. Baseline for a single undocumented param is mid-range; the description neither compensates nor misleads.

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 (Read) and resource (research job status and saved evidence), and the qualifier 'one of your durable research jobs' hints at the async-job family. It doesn't explicitly differentiate from resume_asset_research_job or start_asset_research, but the noun phrase 'status and saved evidence' is distinct enough from those siblings.

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

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

No when-to-use guidance. The description doesn't tell the agent whether to call this after start_asset_research completes, whether it polls, or how it relates to resume_asset_research_job. The reader must infer the workflow from sibling names 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 the safety profile (readOnlyHint, destructiveHint=false). The description adds 'persisted' (indicating stored vs live data) and 'source timestamps' (indicating provenance metadata), which is useful context. However, it doesn't state refresh cadence, rate limits, or what happens outside market hours.

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 tight sentence with no waste, front-loading the verb+resource and appending the value-add qualifiers. 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 parameterless read with an output schema present, the description is near-complete: it names the resource, its scope, and its content composition. The main gap is disambiguation from sibling signal tools, given the crowded namespace.

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?

Zero parameters, so baseline is 4. The description correctly implies a parameterless call with no filtering options, consistent with the empty schema.

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

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

States a specific verb (read) and resource (today's Acai Daily picks), and adds scope qualifiers 'persisted' and 'with public evidence and source timestamps'. It distinguishes itself from siblings like get_alpha or get_equity_signals by naming a distinct resource, though 'Acai Daily picks' is a proprietary term that assumes 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?

No guidance on when to use this vs get_alpha, get_alpha_surge, or other signals tools that could plausibly overlap. With 21 siblings, an agent has no explicit signal for choosing this over the nearest alternatives.

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

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

Annotations already establish readOnly, non-destructive, and open-world behavior, so the bar is lower; the description still adds real context by disclosing that values are cached and by warning that the metrics are proxies rather than true order-flow or sentiment. It stops short of stating refresh cadence or how stale the cache can be.

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

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

Two sentences, zero filler, with the core content (what the data is) front-loaded ahead of the caveat. The disclaimer is placed where it does the most interpretive work.

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

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

An output schema exists, so return-value shape need not be described, and the description covers data provenance, universe, and interpretive limits adequately for a zero-argument read tool. The remaining gap is routing guidance relative to sibling signals such as get_alpha or get_market_sentiment.

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 zero parameters, the baseline is 4 and there is nothing for the description to disambiguate. The listed tickers usefully signal that the covered universe is fixed and non-configurable, which is a small added value over the empty schema.

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

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

The description names the resource (daily price and relative-volume activity proxies), the scope (a fixed set of five tickers: MSTR, COIN, CRCL, HOOD, NVDA), and the freshness model (cached). It implicitly differentiates from get_market_sentiment by disclaiming sentiment measurement, though it never states an explicit verb like 'retrieve'.

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

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

There is no explicit when-to-use, but the closing sentence functions as an exclusion: do not treat this as order-flow or investor-sentiment data, which steers agents away from misuse and toward siblings like get_market_sentiment. No alternative tool is named and no prerequisites are stated, so guidance remains implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful behavioral context beyond annotations: the data source is public ETH/USDT daily candles, and WETH is treated as ETH-equivalent. It does not cover rate limits or freshness, but the annotations carry the safety profile.

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

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

Two tight sentences with no wasted words. The primary output is front-loaded, and the WETH equivalence note earns its place by preventing an asset-mismatch mistake.

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 an output schema, zero parameters, and annotations covering safety, the description is complete enough. It states what data is returned, the source, and the asset equivalence, leaving no material gap for correct invocation.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter syntax or semantics to explain, and the schema already has 100% description 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 the tool returns ETH realized volatility and 30-day swing support/resistance from public ETH/USDT daily candles. It is specific about the resource and data source, but it does not distinguish itself from sibling tools or state why an agent would choose it over alternatives.

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

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

No when-to-use guidance, no alternatives, and no exclusions are provided. The agent can infer that the tool is for ETH levels, but the description does not explicitly say when it should be selected versus other market-data tools in the sibling list.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, destructiveHint=false, so safety is largely covered. The description adds the key behavior beyond the annotations: this is an async/stateless job pattern where the same inputs are re-submitted to poll for completion. It doesn't state auth or cost requirements, but the polling semantics are the non-obvious trait.

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

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

Two tightly written sentences, front-loaded with the core purpose and then the usage/polling caveat. No filler; every clause carries instruction value.

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

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

For a 2-parameter tool with an output schema, the description needn't explain return values, and it does supply the async polling behavior. Remaining gaps (when to prefer this over check_token_security, any auth/cost notes) are minor but present.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It usefully clarifies that chain must be supported (enum enumerates it) and that address is a contract address, not a ticker. However, it adds no format guidance for the address string (20-128 chars) beyond that constraint.

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 set (run/resume) and resource (exact-contract Forensics), and the 'exact-contract ... not a ticker' phrasing distinguishes it from ticker/asset-level siblings like research_asset. It does not explicitly name a sibling, but the resource is concrete enough for an agent to identify the tool.

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

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

Gives actionable when-to-use guidance: pick a supported chain plus a contract address rather than a ticker, and repeat identical inputs if research is still running. It clarifies the resume condition but offers no explicit exclusion against overlapping siblings (check_token_security, research_asset).

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

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

Annotations already declare readOnlyHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavior the annotations cannot convey: a 30-day retention window, sampling that starts on first request, and the absence of historical backfill — all of which affect whether a call will return useful 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?

Two tight sentences with no waste. The availability constraint is stated up front, and the no-backfill caveat is placed last where it reads as a clear warning.

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?

An output schema is present, so return values need not be described, and the annotations cover safety. The description adequately covers availability limits. The only gap is scope — it never says what market or universe these snapshots cover — but for a zero-parameter tool this is a minor omission.

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

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

The tool takes zero parameters, which is the baseline-4 case. There is nothing for the description to clarify beyond what the empty schema already communicates.

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 precisely identifies the resource: persisted hourly market-sentiment and regime snapshots. It implicitly distinguishes itself from the get_market_sentiment and get_market_regime siblings by framing this as the historical/persisted version, though it never states a retrieval verb or names the siblings explicitly.

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

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

The sampling and no-backfill caveats tell the agent when data actually exists, which is a meaningful usage condition. However, there is no explicit guidance on when to call this versus get_market_sentiment or get_market_regime, so the routing decision is left to inference.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context by noting the regime is 'cached' (implying potential staleness) and that it includes rule-based confidence, timestamp, inputs, and reasoning.

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 that packs all essential output attributes without waste. Every element (cached, unified, regime categories, confidence, timestamp, inputs, reasoning) earns its place.

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

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

Given no parameters and an existing output schema, the description is sufficiently complete: it names the regime categories and the accompanying metadata. Annotations cover the safety profile, so no critical context is missing for correct invocation.

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

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

The tool takes zero parameters, so there are no parameter semantics to document. The baseline for zero params is 4, and the description does not need to compensate for any schema gaps.

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 resource: a cached crypto-market regime with enumerated values (risk_on, neutral, risk_off) and associated metadata. It is clear what the tool returns, but it does not differentiate itself from siblings like get_market_sentiment or get_market_history.

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

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

The description only characterizes the output; it offers no guidance on when to call this tool versus alternatives, nor any prerequisites or exclusions. An agent must infer usage from the name alone.

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

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

Annotations already establish readOnly/non-destructive/open-world, so the safety profile is covered. The description adds a genuinely useful trait those annotations do not carry: the data is cached, which tells the agent results may be stale. It does not quantify cache TTL, but this is real added 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 tightly packed sentences. The core payload is front-loaded and the operational caveat ('cached') lands before the closing note, with 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?

With an output schema present, the description need not explain return shapes, and it does not need to — the field list is somewhat redundant with the schema. For a no-param cached read tool this is essentially complete; only cache staleness duration is left unspecified.

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

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

Zero parameters, so the baseline is 4. The description reinforces this with 'no input required', correctly telling the agent there is nothing to supply and no filtering options to consider.

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 resource precisely (crypto market sentiment snapshot) and enumerates its payload — BTC price, 24h change, fear/greed, confidence, source-attributed reasoning. That content list implicitly separates it from siblings like get_market_regime or get_market_history, though no sibling is named explicitly.

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

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

'Current' and 'snapshot' imply this is the real-time-state lookup rather than the historical one (get_market_history) or the regime classifier (get_market_regime), so usage is inferable. There is no explicit when-to-use vs. alternative statement, and no guidance on how the cached freshness limit should affect the decision to call 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 declare readOnlyHint, openWorldHint, and destructiveHint, covering the safety profile. The description adds the data source (Hyperliquid) and an availability caveat ('where available'), but does not disclose rate limits, authentication needs, or refresh behavior, so it adds only moderate 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?

Two tightly written sentences: the first defines the resource and its contents, the second states the use case. Every phrase earns its place, with no repetition 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?

Given a no-param, read-only tool with an output schema and rich annotations, the description covers what the tool returns (perps context, funding, OI) and why to use it. A minor gap is the lack of detail on data freshness or scope (e.g., all perps vs. specific assets), but it is largely 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?

With zero parameters, the schema has no parameter semantics to explain; the baseline for 0 params is 4. The description appropriately adds no parameter details because none exist.

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—perpetual futures market context from Hyperliquid—and lists included data (funding, open interest), which distinguishes it from generic market-data siblings. However, it omits an explicit retrieval verb and does not name any sibling tool, 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 states a clear use case ('Use to assess positioning and liquidation risk'), giving the agent a concrete reason to call it. It does not, however, mention when not to use it or which alternative tools (e.g., get_market_sentiment) might be better for other analyses.

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered externally. The description adds some behavioral context by noting the payload combines odds with "recent market context," but it is silent on freshness/refresh cadence, event coverage breadth, and pagination or result limits.

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

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

Two short sentences, front-loaded with what is returned before the usage hint; no filler or repetition. It is efficient, though the second sentence restates the same idea in slightly different wording rather than adding new 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?

An output schema exists, so the description need not enumerate return fields, and for a zero-parameter read tool it covers purpose and usage adequately. It stops short of describing event coverage or data recency, which would matter for an open-world data feed.

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

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

The tool takes zero parameters, which is the baseline-4 case: there is no parameter syntax for the description to explain. The description correctly signals a no-argument, fetch-everything shape.

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 resource (crypto-relevant prediction-market events and odds) plus the extra value returned (recent market context), so the agent knows exactly what comes back. It does not explicitly differentiate from adjacent siblings such as get_market_sentiment or get_market_regime, which also report crowd/market expectations.

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

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

"Use to gauge crowd expectations for crypto and macro events" gives a clear invocation context, but there is no when-not-to-use guidance and no named alternative for sentiment/expectation data among the many sibling tools. Usage is implied rather than routed.

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, non-destructive, open-world behavior, so safety is covered. The description adds the scoping detail that only persistent exact-contract monitors and their saved check state are returned, but it does not add auth, rate-limit, pagination, or other behavioral context beyond that scope. With an output schema present, return values need not be described.

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, front-loaded with the verb and resource, with no filler. Every component (scope, artifact) 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 list tool with annotations covering safety and an output schema covering return shape, the description gives enough to call it correctly. No essential context 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?

There are no parameters, so the baseline is 4; the empty schema and 100% description coverage mean no parameter semantics need explaining. The description correctly does not invent parameter details.

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 (List) and resource (asset monitors), plus a scope qualifier (only your persistent exact-contract monitors) and the returned artifact (saved check state). This distinguishes it from siblings like check_asset_monitor, create_asset_monitor, and stop_asset_monitor.

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

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

The description implies usage by saying it lists monitors, but it gives no explicit when-to-use guidance, no when-not-to-use, and does not point to check_asset_monitor or other siblings as alternatives. The agent must infer that this is the enumeration tool rather than a status-check 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=true, destructiveHint=false and openWorldHint=true, but the description adds genuinely non-derivable behavior: the check is 'bounded' and 'fresh' (not cached), inputs stay constant across polls, the agent owns the polling cadence, and the operation is stateless enough that it 'may stop at any time'. That clarifies this is a one-shot pull rather than a persistent background subscription — useful context beyond the annotation set. It stops short of saying what happens if the 'bounded' check cannot complete or how polling limits are enforced.

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

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

Two short sentences, no filler, with the core action front-loaded and the read-only/polling caveat second. Every clause carries information and nothing is 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?

An output schema exists so return values need not be described, and the safety/polling model is covered. But for a tool with 4 parameters at 0% schema coverage and five confusable siblings, the definition omits parameter meaning and any differentiation from the rest of the monitor family, leaving the agent under-equipped 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% for four parameters, so the description carries the full explanatory burden and largely fails it. 'One exact contract' loosely implies chain+address, but the optional includeSecurity and includeForensics flags — which materially change the payload — are never mentioned, and the chain enum with nine chains is not acknowledged either.

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 an action (a 'bounded fresh check') and a resource ('one exact contract'), which is more than a tautology. However, against siblings named create_asset_monitor, check_asset_monitor, list_asset_monitors and stop_asset_monitor, it never clarifies whether this creates a monitor, checks one, or performs a standalone one-shot check — 'same inputs on each poll' implies repeated invocation but the tool takes no monitor ID, leaving the relationship to the monitor family ambiguous.

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

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

There is no explicit when-to-use guidance and no alternatives are named despite five sibling tools in the same monitor family. The sentence about polling frequency describes the operating model rather than routing the agent to the correct tool, so an agent has no stated basis for choosing this over check_asset_monitor or create_asset_monitor.

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

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

Annotations already cover the read-only, non-destructive, open-world profile, so the description is not required to restate safety. It earns credit for adding two non-obvious behaviors: that each included member route burns its own quota, and that repeating identical inputs resumes a failed (503) Forensics run. Return shape is left to the output schema.

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

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

Three dense sentences with no filler, and the composition/scope statement is front-loaded ahead of the quota and retry caveats. The 503-resume note is slightly abrupt but operationally valuable rather than padding.

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 an output schema present, the description is not obliged to describe return values, and annotations cover the safety profile. It supplies the quota cost and failure-recovery behavior an agent needs, leaving only the meaning of chain/address and the tool's output nature unspecified.

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

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

Schema coverage is 0%, so the description carries the burden, and it only partially meets it. It loosely maps the two boolean flags to named features ('include Forensics or token security'), which adds real meaning, but chain and address are never explained. The enum on chain is self-documenting, yet address constraints and the required-pair semantics remain unaddressed.

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

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

The verb 'Combine' plus 'exact-contract evidence' gives a rough sense of an aggregation tool, and naming Launch/Surge/Daily hints at which sibling sources are bundled. However, those source names are internal jargon that an agent cannot map confidently to get_alpha_launch, get_alpha_surge, or get_daily_picks, and the description never states what the tool actually produces (an asset research report). The purpose is implied rather than stated.

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

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

The description does convey composition semantics (which members are included by default, and that Forensics/token security are opt-in), which implies when to reach for this tool instead of calling the individual sources. But it never explicitly says when to prefer research_asset over get_forensics or check_token_security, nor when to use start_asset_research versus this 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?

With destructiveHint=false and readOnlyHint=false already set, the description adds real context: the job resumes with its 'original exact-contract inputs', so the caller cannot alter parameters, and completed jobs are guarded against rerun. It does not cover auth requirements or rate limits, but the added behavioral semantics are meaningful.

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

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

A single front-loaded sentence with zero filler; the scope constraint and the exclusion are both stated efficiently.

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

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

An output schema exists, so return values need not be explained, and the annotations carry the safety profile. The description covers applicability and the input-locking behavior, leaving only minor gaps around failure modes and ID provenance.

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

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

One parameter (taskId) with 0% schema description coverage, so the description must compensate. It implies taskId identifies a job whose inputs are locked to the original contract, but never states the format, source of the ID, or what happens on an unknown ID.

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 (resume) and resource (research job), and scopes it to partial or interrupted jobs rather than completed ones. It implies a distinction from siblings like start_asset_research and get_asset_research_job, but never names an alternative explicitly.

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

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

Gives a clear use condition (a job that is partial or interrupted) and an exclusion (completed jobs are not rerun). No alternative tool is named for the cases it excludes, which is the only gap.

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=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. Beyond that, the description adds genuinely useful context: jobs are 'owner-scoped' (auth scoping), 'resumable' (lifecycle), and 'Each source consumes its usual member quota' (rate/quota cost). It does not explain failure/idempotency behavior beyond the word 'stable'.

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

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

Three tight sentences with no filler, front-loaded on what is created and followed by cost and lifecycle notes. Density of jargon like 'exact-contract' slightly reduces immediate readability, but nothing is wasted.

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

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

An output schema exists, so return values need not be explained. For a mutating, quota-consuming job starter, the description covers ownership, quota cost, optional modules, and the poll/resume lifecycle. The main gap is that chain/address semantics are undocumented at 0% schema coverage.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partially does: it explains requestKey ('stable requestKey' hinting at idempotency) and the Forensics/security flags. The chain enum, address bounds, and their semantics are left entirely to the schema, which documents nothing.

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 verb and resource: 'Create an owner-scoped, resumable exact-contract job.' It conveys that this starts an asset research job scoped to a contract, which is more specific than a tautology. However, 'exact-contract' is jargon and the text never explicitly distinguishes this from sibling 'research_asset', so the differentiation is partial.

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

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

It gives clear workflow context: 'Supply a stable requestKey, then poll or resume by taskId,' which implicitly routes the agent to get_asset_research_job / resume_asset_research_job after starting. It also notes the optional Forensics/security inclusion. It stops short of stating when NOT to use this versus research_asset or the monitor 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 destructiveHint=true and readOnlyHint=false, so the mutation profile is covered. The description adds genuinely useful scope detail beyond that: stopping affects only the monitor and not research history or other members' monitors, which is exactly the kind of blast-radius information an agent wants before a destructive call.

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

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

Two short sentences, action stated first, scope caveat second. No filler, no repetition of the title.

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

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

With an output schema present, return values need no explanation, and annotations carry the destructive/read-only profile. The description's remaining need—identifying which monitor id to pass—is the only real omission for this one-parameter tool.

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

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

Schema coverage is 0% and the single parameter (taskId, uuid) is never mentioned in the description. "One of your persistent monitors" implies you supply an identifier, but the description gives no hint of format or where to obtain the id (e.g. list_asset_monitors). Self-evident enough not to be a severe gap, but it fails to compensate for the coverage gap.

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

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

States a specific verb ("Stop") and resource ("one of your persistent monitors"), which is clearly distinct from siblings like create_asset_monitor, list_asset_monitors, and check_asset_monitor. It doesn't explicitly name alternatives, but the action and scope are unambiguous.

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

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

Usage is implied by the name and the word "persistent monitors," but the description never says when to use this versus check_asset_monitor or list_asset_monitors, nor what prerequisites (e.g. an active monitor) apply. The exclusion sentence covers consequences, not when-to-use.

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