Central Command

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

Adds context beyond annotations: states READ + WRITE behavior, details destructive live actions requiring confirm_live, explains auth (X-Api-Key, linked Connect keys preferred), cost, rate limit, and return format. 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 dense yet well-structured, front-loading the purpose then detailing behaviors and guidelines. Every sentence adds value 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 complexity (10 parameters, nested objects, output schema exists), the description covers purpose, usage, behavioral traits, auth, cost, rate limit, and return format. It references the output envelope, making it complete.

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

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

Schema coverage is 100%, but the description adds significant meaning: it categorizes actions (safe/read, write, destructive live) and explains confirm_live and force_paper in depth. It also partially describes the settings object, which is helpful.

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 runs the Central Command agent console and lists specific actions (guide/whoami, create/update strategies, backtest, deploy, execute, live orders), distinguishing it from siblings by focusing on strategy lifecycle and account actions.

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: start with guide then whoami, prefer paper, never invent outbound-proxy failures, and note that confirm_live is required for destructive live orders. However, it does not explicitly contrast with 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?

The description comprehensively discloses behavioral traits: read-only (consistent with annotations), caching (~1800s), authentication methods, cost ($0.002), rate limit (60/min), and return format. This adds significant context beyond the annotations, which already indicate read-only, idempotent, and non-destructive.

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 with key sections (purpose, behavior, auth, cost, return, guidelines) but contains slight redundancy (e.g., the first sentence repeats the purpose). Each sentence adds value, and it is front-loaded with the core action.

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 output schema exists, the description sufficiently explains the return format and key details (indicators, scores). It also covers caching, auth, cost, and rate limits. For a read-only, zero-required-parameter tool, the description is complete and leaves no critical 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?

There is only one optional parameter (__x_payment) with schema coverage of 100%. The description adds context explaining its purpose (payment proof for x402 retries) and when to use it, which goes beyond the schema description. Baseline 3, plus extra context, justifies a 4.

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

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

The description clearly states the tool scans 36 major crypto assets across multiple categories (BTC, ETH, SOL, alts, memes) for multi-timeframe technical signals including specific indicators (RSI, MACD, etc.). The verb 'scans' and resource 'crypto assets' are specific, and the scope is well-defined.

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 'Use for research / signal context' and advises pairing with cc.agent_strategy for paper trading before live orders, providing positive usage guidance and a related sibling tool. However, it does not explicitly state when not to use this tool versus other similar scanners like cc.central_signal or cc.coinglass_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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and the description reinforces these with 'READ-ONLY. Does not place orders...'. Additionally, it reveals critical behavioral traits: response caching (~300s), authentication methods (X-Api-Key or x402 payment proof), cost ($0.008 USDC), rate limit (15/min), and the nature of billing as a non-side-effect. This far exceeds what annotations provide.

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

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

The description is somewhat repetitive (the first two sentences restate the same idea) and mixes sections without explicit formatting. While front-loaded with key info, it includes a block of tags that could be trimmed. Each sentence adds value, but the repetition detracts from conciseness. It is adequate but not tightly crafted.

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 complexity (multiple data sources), full schema, presence of output schema, and annotations, the description covers all necessary aspects: purpose, behavior, authentication, cost, rate limit, caching, guidelines, and output structure mention. It is complete, with no obvious gaps. The rule allowing omission of return value details when output schema exists is satisfied.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minimal value for the main parameters (symbol and timeframe are self-explanatory). However, it does explain the __x_payment parameter's purpose ('Use when retrying after HTTP 402...'), which is useful context not in the schema. Overall, the description does not significantly enhance understanding beyond the schema.

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

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

The description clearly states the verb-resource combination: 'fetch market data' with 'All-in-one market intelligence' listing specific data types (OHLCV candles, indicators, OI, news). It distinguishes from siblings by emphasizing comprehensiveness ('everything an agent needs in one call'), which is unique among many specialized data tools. The redundancy ('Everything...' repeated) is minor and does not obscure clarity.

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

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

Explicitly states when to use: 'Compute / parse / backtest only — no live orders.' Provides a concrete integration path: 'Feed outputs into cc.agent_strategy with force_paper=true to paper-trade.' Mentions rate limit and cost as constraints. Lacks explicit when-not-to-use comparisons with siblings, but the guidelines are actionable and contextual.

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

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

The description goes well beyond annotations by detailing caching (~60s), auth requirements (X-Api-Key or x402), billing ($0.0005/call), rate limit (120/min), and error handling (402 payment). It explicitly states read-only behavior, no mutation. 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 somewhat long but well-structured with clear sections and no wasted sentences. It efficiently packs essential info without being overly verbose.

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 complexity (3 params, 1 required, output schema present), the description covers billing, rate limits, auth, caching, error handling, and return type. It is fully self-contained for an agent to use 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?

With 100% schema coverage, the description adds marginal value: it reiterates path example and payment retry context. The schema already documents all three parameters adequately, so baseline 3 is appropriate.

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

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

The description explicitly states the tool is a proxy to BloFin public API for market data (tickers, instruments, orderbook, trades, candles) bypassing CORS. This clearly distinguishes it from sibling tools which serve other exchanges or data types.

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 guidelines on when to use (to get public market data without CORS) and how to use (pass parameters exactly, omit unknown fields, retry with payment on 402). It lacks explicit discussion of when not to use or alternative tools, but the context 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 description discloses destructive behavior (can open/close positions), auth requirements, cost, rate limit, tier, and return fields. This adds substantial value beyond the annotations (which already indicate destructiveHint=true and readOnlyHint=false). 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 contains a repetitive sentence (the purpose is stated twice: once in the opening and again after 'Purpose:'). While information-rich, it could be more concise. The structure is front-loaded with the main verb, but the repetition hurts efficiency.

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 complexity (destructive, billing, auth, rate limits, output schema), the description covers all essential aspects: behavior, auth, cost, limits, guidelines, and return format. The output schema is described in text, and annotations cover destructiveness. No gaps remain.

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 100% coverage, but the description adds meaningful context: symbol accepts any format (BTCUSDT, BTC/USDT, BTC-USDT), side described as 'buy or sell', and __x_payment explained as optional payment proof. This enhances the schema descriptions, which were already present but generic.

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 is a unified signal ingestion endpoint that normalizes symbols from any exchange format to executable format and routes to execution. It distinguishes from sibling cc.agent_strategy by stating it should be paired with that tool for paper trading before live orders. The verb is specific (normalize and route), and the resource is clear (signal ingestion).

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 guidance: use for research/signal context, pair with cc.agent_strategy before any live order, and do not invent fills. It also mentions auth requirements (X-Api-Key) and cost. However, it does not explicitly exclude other siblings like cc.external_signal, so it loses one point for lacking when-not 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 declare readOnlyHint, destructiveHint false, idempotentHint. The description adds caching (~1800s), auth methods (X-Api-Key or x402), rate limits (30/min), cost ($0.002), and explicitly states no orders or mutations. 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?

Well-structured with clear sections (behavior, auth, cost, guidelines) and front-loaded purpose. However, the first sentence is repeated almost verbatim ('Unique signal. Purpose: ...'), adding minor 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 simple parameter set (1 optional), rich annotations, and described output schema (direction, size, fill status, dates), the description provides all necessary context for correct agent 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?

Only one parameter (__x_payment) with full schema description coverage. The description adds context that it's for retrying after HTTP 402 and not a business parameter. Slightly exceeds baseline by providing helpful operational nuance.

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 detects and tracks CME Bitcoin futures gaps (Friday close vs Monday open) with fill status monitoring, a specific verb+resource. It distinguishes itself from sibling tools that cover strategies, data, news, etc., by highlighting it as a unique signal.

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

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

Explicitly advises use for research/signal context, pairs with cc.agent_strategy (paper) before live orders, and warns against inventing fills from this data alone. Provides 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 readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable context: 'Read-Only. Does not place orders, move funds, or mutate your exchange account.' It also discloses caching (~2700s), authentication, cost ($0.003 USDC), and rate limit (30/min). This fully informs the agent about side effects and constraints 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 verbose and repetitive, e.g., it restates the same information in the opening sentence and the 'Purpose:' field. It includes a long list of tags and redundant phrasing. Although it contains necessary details, the structure could be more concise and front-loaded. Every sentence is not clearly earning 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 complexity (aggregates multiple data types) and the presence of an output schema, the description covers all necessary context: it explains return type ('Normalized market microstructure data'), caching, auth, cost, rate limiting, and usage guidelines. No gaps remain for the agent to safely invoke the 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 100% with two parameters: symbol and __x_payment. The description adds meaning beyond the schema by noting symbol defaults to 'top 20' and explaining __x_payment as an alternative for HTTP authentication. While the schema already covers basics, the description enriches parameter understanding. Baseline 3 due to high coverage, +1 for additional context.

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 provides 'Comprehensive Coinglass derivatives data including open interest, liquidations, funding rates, and long/short ratios.' This specifies the verb (provides) and resource (aggregated derivatives intelligence). However, it does not explicitly differentiate from sibling tools like cc.open_interest or cc.funding_rates, which may offer more focused data. The purpose is clear but not perfectly distinguished.

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 guidance: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' It also warns about caching (45-min) and authentication requirements. This clearly tells the agent when and how to use the tool, and when not to rely on 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds: 'Behavior: READ-ONLY. Does not place orders...', caching duration (~300s), authentication methods (X-Api-Key or x402 payment proof), cost ($0.005 USDC per call), rate limit (30/min), and that it's billing not a side effect. This is extensive behavioral disclosure 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 well-structured with labeled sections (Purpose, Behavior, Auth, Cost, etc.) and is front-loaded with core purpose and caching. However, the first sentence is repeated verbatim ('Fetches footprint/orderflow data... 5-minute cache.') which is a minor redundancy. Still efficient overall.

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

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

Given the tool's complexity, the description covers purpose, behavior, auth, cost, rate limits, caching, return format ('Orderflow footprint matrix'), and usage guidelines. There is an output schema present, so return details are not required but still provided. All necessary context for an agent to use the tool correctly is 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 100% with clear descriptions for both parameters (symbol and __x_payment). The description adds context about the __x_payment parameter's use in retrying after HTTP 402, which complements the schema. No redundant repetition. Baseline 3 plus one for extra context.

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

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

The description clearly states the verb 'Fetches' and the resource 'footprint/orderflow data' indicating buy vs sell volume imbalance at each price level. The title 'Orderflow Footprint Data' aligns perfectly. It distinguishes from siblings like cc.coinglass_data by specifying footprint/orderflow specifically.

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?

Explicit guidelines are provided: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' This tells the agent when and how to use the tool, and what not to do, including a suggestion to pair with a sibling 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, idempotentHint=true, destructiveHint=false. The description adds significant context: explicitly states READ-ONLY, does not place orders or mutate accounts, explains cost and rate limits, and clarifies billing is not a side effect. No contradictions.

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 lengthy and contains repetition (e.g., 'Comprehensive TA computation engine' appears twice). While it is well-organized with sections, the redundant phrasing reduces conciseness. Front-loading is good, but several sentences could be streamlined.

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 complexity (5 params, output schema exists), the description covers purpose, behavior, usage guidelines, cost, auth, and output details. It links to a sibling for paper trading. It lacks explicit error handling or response structure, but the output schema likely covers that.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by listing the supported indicators and explaining the __x_payment parameter usage, which goes beyond the schema. It does not detail symbol or timeframe format, but the schema already provides enough.

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's a comprehensive TA computation engine with 25+ indicators on any OHLCV data. It lists many indicators and explicitly distinguishes from siblings by emphasizing computation only, not live orders. The verb+resource is specific and unambiguous.

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

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

The description explains that it is for compute/parse/backtest only with no live orders, and suggests feeding outputs into cc.agent_strategy for paper trading. It also notes authentication and cost. However, it does not explicitly compare to similar siblings like cc.indicator_generator, leaving some ambiguity about when to choose 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 indicate readOnlyHint, idempotentHint, destructiveHint. The description adds valuable behavioral traits: caching (~3600s), READ-ONLY claim, authentication methods (X-Api-Key or x402 payment proof), cost ($0.001 USDC per call), rate limit (60/min), and tier. No contradictions with annotations; the description enhances understanding 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 well-structured and front-loaded, starting with a clear purpose and then covering behavior, caching, auth, cost, rate limit, returns, and guidelines. Every sentence provides essential information without redundancy. It is appropriately sized for the tool's complexity.

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 moderate complexity (one optional parameter, output schema exists), the description covers all necessary aspects: purpose, behavior, caching, auth, cost, rate limit, return summary, and usage guidelines. The existence of an output schema reduces the need to detail return fields. The description is complete for an agent to correctly select and invoke the 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?

There is only one parameter (__x_payment) with 100% schema coverage. The description adds that it is 'Not a business parameter' and explains its purpose (retry after HTTP 402). This clarifies the parameter's role beyond the schema description. A score of 4 reflects the added value while acknowledging the schema already covers the basics.

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 provides upcoming high-impact macroeconomic events with forecast vs previous values. It specifies verbs like 'Call' and details the resource (economic calendar). The examples (CPI, FOMC, NFP) and the tag line 'macro, calendar, fomc, cpi, nfp, economic' distinguish it from siblings like cc.market_news or cc.fear_greed.

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 includes explicit guidelines: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' This clearly states when to use (research/signal) and when not to (not for direct order fills), and suggests an alternative sibling (cc.agent_strategy) for paper trading.

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. The description adds context on caching (60-min/3600s), authentication methods, cost ($0.002), rate limit (30/min), and billing details, with no contradictions.

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 comprehensive but slightly repetitive (purpose stated twice). It is well-structured with front-loaded purpose, followed by behavior, auth, cost, rate limits, returns, and guidelines. Every sentence adds 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?

Given the complexity (payment, caching, rate limits, multiple auth methods), the description covers all necessary aspects thoroughly. Output schema exists, so return values are documented elsewhere.

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?

Only one optional parameter (__x_payment) with 100% schema coverage. The description explains its purpose ('retrying after HTTP 402 if your MCP client cannot set custom headers'), adding value beyond the schema.

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

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

The description clearly states the tool provides real-time Bitcoin/crypto ETF inflow/outflow data tracking institutional positioning, listing specific ETFs (GBTC, IBIT, FBTC). It distinguishes from siblings by focusing on ETF flows and caching behavior.

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

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

The description explicitly says 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone,' providing 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?

Description explicitly states the tool is destructive, can open/close positions, requires X-Api-Key auth and exchange credentials, costs $0.005 USDC per call, and has a 60/min rate limit. All critical behavioral traits are disclosed 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?

Description is informative but contains repetition (first sentence and 'Purpose' section overlap). It is structured with sections but could be more concise. Still, it is well-organized and front-loaded with the core purpose.

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

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

Given the tool's complexity (destructive, paid, rate-limited, auth required) and presence of output schema, the description covers all necessary aspects: behavior, auth, cost, rate limit, return description, and usage guidelines. An agent can correctly invoke this tool without additional info.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context for the __x_payment parameter (explains its purpose for HTTP 402 retries) but does not significantly elaborate on other parameters beyond what the schema provides. Adequate but not exceptional.

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 clearly states the tool is a public-facing webhook endpoint for TradingView alerts, custom bots, and third-party signal providers, and that it normalizes and forwards to execution. This distinguishes it from siblings like cc.central_signal and cc.agent_strategy.

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?

Explicit 'Guidelines' section advises using for research/signal context, pairing with cc.agent_strategy (paper) before live orders, and not inventing fills from this data alone. Provides 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?

Description discloses read-only behavior, caching (~1800s), payment model, and rate limit beyond annotations. No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint).

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

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

Well-structured with labeled sections and front-loaded core info. Slightly verbose with repeated phrase about the index and cache, but overall efficient.

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

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

Given output schema exists, description explains return structure (current value plus 7/30/90 day history). Input schema fully covered. Annotations provide safety. Sibling differentiation and usage guidelines 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 has one optional parameter with 100% coverage. Description adds context on when to use __x_payment (retrying after 402 when headers can't be set). No enums or nested objects.

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 clearly states the tool returns the Crypto Fear & Greed composite index with historical values and trend direction. It distinguishes from siblings by encouraging pairing with cc.agent_strategy, and provides tags like 'sentiment' and 'fear-greed'.

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

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

Explicitly advises use for research/signal context, recommends pairing with cc.agent_strategy before live orders, and warns against inventing fills from this data alone. Also details auth, cost, and rate limits.

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

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

Beyond the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), the description adds critical details like caching (~1800s), auth methods (X-Api-Key or x402), cost ($0.001 USDC per call), rate limit (60/min), and that it is billing, not a side effect. 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 well-structured with clear sections (Purpose, Behavior, Auth, etc.) and front-loaded with the key action. It is somewhat verbose but every sentence adds value, especially given the complexity of billing and auth. Minor redundancy (Purpose repeated twice) prevents 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?

Given the tool's 2 parameters (100% coverage) and the existence of an output schema, the description covers all aspects: behavior, auth, cost, rate limit, return summary ('Per-symbol funding rate data with exchange-level breakdowns and predicted next funding'), and usage context. No 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 coverage is 100%, so the schema already documents parameters. The description adds value by clarifying that the optional symbol defaults to 'all major' and explaining the __x_payment parameter's role in retry scenarios, which is not in the schema's description but aligns with it.

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

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

The description explicitly states it provides 'Current and predicted perpetual futures funding rates across all major exchanges via Coinglass with 30-min cache'. The verb 'call' and resource 'funding rates' are specific, and the scope (all major exchanges) is clear. It distinguishes itself from siblings like cc.agent_strategy by suggesting pairing.

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 guidelines: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' This tells when to use and when not to, with a clear alternative 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?

Discloses read-only behavior, caching (~1800s), authentication (X-Api-Key or x402), cost ($0.003 per call), rate limit (30/min), and that it does not place orders or mutate accounts. Adds value beyond annotations without contradiction.

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

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

The description is verbose with redundancy (e.g., purpose repeated twice). While structured into sections, it could be more concise. Some sentences ear their place, but not all are efficient.

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

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

Given the low complexity (1 optional param, annotations, output schema), the description covers all necessary aspects: return values (positions, alerts), cost, rate limit, caching, authentication, and usage guidelines. No 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 coverage is 100%, baseline 3. The description adds context for the __x_payment parameter: it is for retrying after HTTP 402 when MCP client cannot set custom headers, and that it is not a business parameter. Enhances understanding beyond schema.

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

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

The description clearly states it provides whale positions and activity alerts from Hyperliquid DEX. The verb 'call' is generic, but the resource is specific. It implicitly distinguishes from sibling tools by domain, but does not explicitly differentiate.

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?

Explicit guidelines: use for research/signal context, pair with cc.agent_strategy (paper) before live orders, and do not invent fills from this data alone. Provides when-to-use and when-not-to-use with 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?

The description explicitly states read-only behavior, no fund mutation, and includes billing details (cost, rate limit, auth) beyond what annotations provide. Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds valuable context like rate limits and payment flow without contradiction.

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

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

The description is repetitive, with the actions list duplicated. It is well-structured with sections but could be more concise. Length is appropriate for the complexity, but redundancy reduces efficiency.

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 complex tool with multiple actions, 8 parameters, billing, rate limits, and error handling, the description covers all necessary aspects: purpose, actions, returns, behavior, auth, cost, and guidelines. Output schema exists, so return format explanations are adequate.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add new semantic meaning for individual parameters beyond the schema's descriptions. It lists actions and returns but does not elaborate on parameter usage specifics.

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 is an AI-powered indicator workshop with a defined set of actions (generate, list, get, delete, get_draft, save) and return formats. It distinguishes itself from sibling tools by focusing exclusively on indicator generation, code, and metadata, which is a specific niche not covered by others.

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 guidelines on parameter usage, error handling (402), and retry logic. However, it does not explicitly state when to use this tool versus alternatives, nor does it give exclusion criteria. The context is clear but lacks comparative 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 declare readOnlyHint and idempotentHint. Description adds caching (~1800s), auth methods, rate limit, cost, and billing details, providing extensive behavioral context 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?

Concise but thorough. Uses clear headings (Behavior, Auth, Cost, Rate limit, Returns, Guidelines, Tags). Front-loads purpose and delivers value in every 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?

Given an output schema exists, description still explains return format (3D matrix). Covers auth, cost, rate limits, caching, and usage guidelines. Complete for a complex 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 100% and description does not add additional semantics to parameters. Description focuses on output and behavior, not on 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?

The description clearly states the tool provides 'liquidation cluster visualization data' showing where leveraged positions would be force-closed. It distinguishes from siblings like cc.liquidation_max_pain and cc.agent_strategy.

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?

Explicit guidelines: use for research/signal context, pair with cc.agent_strategy before live orders, and 'Do not invent fills from this data alone.' Clearly states when and when not to use.

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. The description adds substantial context: caching (~1800s), authentication methods (X-Api-Key or x402 with payment), cost ($0.003 USDC), rate limit, and tier. It also states 'Behavior: READ-ONLY' and clarifies billing is not a side effect. No contradictions.

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

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

The description is front-loaded with purpose but contains redundant phrasing: 'Identifies the exact price levels where maximum liquidation cascades would trigger for both longs and shorts.' appears twice. While details are valuable, the repetition reduces conciseness. Structure is otherwise logical.

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 lacking an explicit output schema, the description lists returned fields (long_max_pain_price, short_max_pain_price, current_price, distance_to_each). It also covers auth, cost, rate limits, caching, and usage guidelines. For a tool with annotations and only two parameters, the description is fully comprehensive.

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

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

Schema coverage is 100%, so the description does not need to explain parameters. However, the description repeats the __x_payment parameter's purpose already covered in schema, adding no new insight. The symbol parameter is not elaborated beyond schema. Baseline score of 3 is appropriate as the description adds minimal value over the schema.

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

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

The description clearly states the tool identifies exact price levels for maximum liquidation cascades for both longs and shorts. It uses a specific verb ('identifies') and distinguishes from siblings like cc.liquidation_heatmap by mentioning pairing with cc.agent_strategy. The purpose is unambiguous.

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

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

Explicit guidelines are provided: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' These instructions clarify when and how to use the tool, including avoiding live order usage without paper testing.

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. Description adds that it's READ-ONLY, does not place orders or charge fees, is free to list, and mentions optional auth and rate limit. No contradictions.

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?

Description is well-structured with sections for purpose, behavior, auth, cost, rate limit, return format, and guidelines. No redundant sentences; every sentence adds 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?

Given 33 sibling tools and complexity, this description is thorough. Covers purpose, behavior, auth, cost, rate limit, output format, and usage guidance. Output schema exists, so return values are handled, and the description adds a helpful overview.

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?

Input schema has zero parameters and description confirms 'No parameters. Empty object.' Schema coverage is 100%, so description adds no new parameter meaning but accurately reflects the fact.

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 lists catalog endpoints with details like names, prices, parameters, and tiers. It uses specific verb 'list' and resource 'catalog endpoints', and distinguishes from siblings by noting this is for discovering which cc.* tools exist.

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

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

Explicitly says 'Call this first. Then invoke cc.<slug> with required params.' Also mentions admin-only tools are omitted, providing clear guidance on when and how to use 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?

Beyond annotations (readOnlyHint, etc.), the description details that the tool is READ-ONLY, does not mutate exchange accounts, responses may be cached (~3600s), and includes auth methods, cost ($0.001 USDC), and rate limits (60/min). This adds extensive behavioral context without contradiction.

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

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

The description is well-structured with clear sections (purpose, behavior, auth, cost, rate limit, returns, guidelines) and front-loaded with the key purpose. Minor redundancy exists (purpose stated twice), but overall it is efficient and earns its 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?

Given the tool's complexity (billing, caching, auth variants) and the presence of an output schema, the description covers return values (time-series of long_percent, short_percent, ratio), usage context, and all behavioral aspects thoroughly. No gaps are apparent.

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

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

Schema coverage is 100% and the description only repeats what the schema already provides for both parameters (symbol required, __x_payment optional). No additional meaning or usage hints are added beyond the schema, meeting the baseline but not exceeding it.

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 the 'Global long vs short account positioning ratio from Coinglass showing retail sentiment', specifying a precise verb and resource. Although it does not explicitly differentiate from sibling tools like cc.fear_greed or cc.funding_rates, the purpose is unambiguous and distinct enough.

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 explicit: 'Use for research / signal context. Pair with cc.agent_strategy (paper) before any live order. Do not invent fills from this data alone.' It provides context on when to use, but lacks explicit statements on when not to use or alternatives, lowering from 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?

The description goes beyond annotations by detailing caching (30-min cache), authentication (X-Api-Key or x402 payment), billing ($0.001 USDC per call), rate limit (60/min), and that it is read-only with no side effects. This fully discloses behavioral traits.

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 with a clear front-loaded first sentence and logical sections (purpose, behavior, auth, cost, rate limit, returns, guidelines). However, it redundantly states the purpose line twice, slightly reducing conciseness.

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

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

The description covers output (MA periods and timeframes), caching, billing, auth, rate limits, and usage guidelines. Given the presence of an output schema and rich annotations, it is largely complete. It lacks error handling details but is sufficient for most use cases.

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

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

Schema coverage is 100%, so the input parameters are already fully documented. The description adds marginal value by explaining the optional payment parameter's use case, but does not enrich the meaning of the required 'symbol' parameter beyond the schema.

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

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

The description clearly states it fetches multi-period moving average values (SMA/EMA) via Coinglass. The verb 'fetch' and resource 'moving average data' are specific. However, it does not distinguish from sibling tools like cc.central_signal or cc.indicator_generator, which may also provide technical indicators.

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 'Use for research / signal context' and advises pairing with cc.agent_strategy (paper) before live orders. It also warns not to invent fills from this data. This provides clear usage context, though no alternative tools 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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds behavioral details: read-only, does not mutate account, responses cached (~1800s), auth methods (X-Api-Key or x402), cost ($0.002 USDC), rate limit (30/min), and returns categorized articles. 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 well-structured with clear sections (purpose, behavior, auth, cost, rate limit, returns, guidelines). It is slightly lengthy but does not contain unnecessary redundancy. Efficient communication overall.

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

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

Given the tool's simplicity (2 optional params, read-only, output schema exists), the description covers all essential aspects: purpose, read-only behavior, caching, authentication, pricing, rate limiting, return format, and usage guidelines. No gaps identified.

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

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

Schema coverage is 100% with both parameters documented. The description adds minimal semantic value beyond the schema; it mentions filtering by category implicitly ('btc, eth, sol, macro, all') but does not elaborate on the payment proof parameter semantics. Baseline of 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 clearly states the tool aggregates crypto and macro market news with relevance scoring and categorization. It uses a specific verb ('Call') and resource ('market news'), and the purpose is distinct from siblings like cc.agent_strategy (paper strategy) or cc.fear_greed (sentiment index).

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

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

Explicitly advises using for research/signal context, pairing with cc.agent_strategy before live orders, and warns against inventing fills from this data alone. Provides 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?

Discloses that the tool can place/cancel orders and manage positions, and explicitly states to treat it as potentially destructive. This aligns with annotations (destructiveHint=true) and adds context about needing confirmation for live trading. Also covers cost and rate 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?

The description is well-structured with labeled sections, but it is verbose and contains redundancy (e.g., 'Autonomous AI agent specialized in...' appears twice). Some sentences could be combined or trimmed without losing 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?

Covers all critical aspects: behavior, authentication, cost, rate limits, tier, return type, and usage guidelines. Given the presence of an output schema and annotations, the description provides sufficient contextual completeness for an autonomous AI agent 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 100% with descriptions for all parameters. The description adds value by explaining the purpose of __x_payment (retry after HTTP 402) which is not in the schema. It also clarifies that conversation_id is optional and that unknown extras are ignored.

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 is an autonomous AI agent for strategy development, backtesting, and market monitoring. It distinguishes itself from sibling tools by explicitly mentioning its ability to place/cancel orders and manage positions, which is unique among the listed 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?

Provides explicit guidelines: prefer paper/simulation, require human confirmation for live trading, and correctly report errors. It also explains authentication and cost context. However, it does not explicitly state when not to use it or name 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?

Discloses read-only behavior, no order placement or fund movement, caching (~1800s), authentication methods, cost ($0.001 USDC per call), rate limit (60/min), and tier. Adds value beyond annotations which already declare readOnlyHint true and idempotentHint true. No contradictions.

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?

Description is well-structured with clear sections: purpose, behavior, auth, cost, rate limit, guidelines. However, it contains slight redundancy (purpose stated twice) and is somewhat long, though every sentence adds value. Could be trimmed slightly without losing information.

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

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

Given the tool has an output schema, good annotations, and only 3 parameters (1 required), the description covers all relevant context: caching, auth, cost, rate limit, pairing advice, and behavior. No gaps identified.

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

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

Schema description coverage is 100%, so baseline is 3. Description does not add significant extra meaning beyond what the schema already provides for parameters. The description of __x_payment includes a usage note but it's already clear from schema. No additional semantics for 'symbol' or 'interval' beyond schema.

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

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

The description clearly states the tool returns historical and current aggregated open interest across major exchanges with 30-min cache. The verb 'call' is generic but the resource and scope are specific, distinguishing it from sibling tools like funding_rates or liquidation_heatmap.

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

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

Explicitly says to use for research/signal context, pairs with cc.agent_strategy before live orders, and warns not to invent fills from this data alone. Provides 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?

The description explicitly states the tool is read-only, does not mutate accounts, and details authentication, billing, and rate limits. This adds significant context beyond the annotations, which already indicate readOnlyHint and idempotentHint. 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?

The description is structured with clear sections (Purpose, Behavior, Auth, Cost, Rate limit, Returns, Guidelines) and is relatively concise given the amount of detail. Some repetition (e.g., 'Multi-endpoint Solana RPC proxy') could be trimmed, but overall it's well-organized.

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 nature as a generic proxy for Solana RPC, the description is highly complete. It covers purpose, behavior, auth, billing, rate limits, and usage guidelines. Output schema is implied (standard Solana JSON-RPC response), so no further explanation needed.

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?

While schema coverage is 100% with descriptive parameter names, the tool description adds little beyond stating the method is 'Solana RPC method' and params is an array. The additional context about __x_payment is useful but basic. Baseline 3 is appropriate as schema already documents parameters.

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

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

The description clearly identifies the tool as a Solana Multi-RPC proxy for any JSON-RPC method with automatic failover. It distinguishes itself from sibling tools that are trading or data specific by focusing on generic Solana RPC access.

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 guidance on when to use this tool (any Solana JSON-RPC method) and includes a preference for read methods, but does not explicitly state when not to use it or offer alternatives among siblings. The guidance is clear but not exhaustive.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds significant context: authentication methods (X-Api-Key or x402), cost ($0.002 USDC per call), rate limit (10/min), return type (AI response with optional draw_commands), and billing details. All are consistent with annotations and provide essential behavioral information 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 well-structured with labeled sections (Behavior, Auth, Cost, Returns, Guidelines, Tags) and front-loaded purpose. However, it is somewhat repetitive (e.g., 'Full AI trading assistant...' appears twice). Still, every sentence adds value, so it's efficient but not maximally concise.

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

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

Given the tool's complexity (6 params, output schema exists, many siblings), the description covers all essential aspects: purpose, capabilities, behavioral constraints, authentication, pricing, rate limits, return format, and usage tips. It leaves no critical gaps for an agent to make an informed decision.

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

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

Schema description coverage is 100% for all 6 parameters. The description adds marginal value: explains the __x_payment parameter's special use for retries. Baseline 3 is appropriate; the description does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states the verb 'Call' and the resource 'full AI trading assistant'. It enumerates capabilities (real-time data, position analysis, chart drawing) and distinguishes from specific data tools like coinglass_data or funding_rates by emphasizing its comprehensive chat interface. It effectively conveys the tool's scope and uniqueness.

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 includes a dedicated 'Guidelines' section advising to pass required parameters exactly and handle 402 errors with X-PAYMENT. It also states read-only behavior. However, it does not explicitly mention when not to use this tool or provide alternatives (e.g., squirrel_chat_v2). This is a minor 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?

Description adds significant behavioral context beyond annotations: 'conversational AI that CAN place/cancel orders and manage positions when the linked account allows it. Treat as potentially destructive. Confirm intent before asking it to trade live.' This aligns with destructiveHint=true and readOnlyHint=false, and includes auth and cost details not 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?

Description is comprehensive but not overly verbose. It front-loads the core purpose and then efficiently covers behavior, auth, cost, rate limits, returns, guidelines, and tags. Each sentence serves a purpose, though slightly more conciseness could be achieved without losing 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?

Given the tool's complexity (autonomous trading agent) and presence of output schema, the description covers all essential aspects: purpose, behavior, auth, cost, rate limits, guidelines, and tags. It is complete enough for an agent to decide when and how to invoke this tool safely.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by clarifying __x_payment ('Optional x402 payment proof... Not a business parameter') and conversation_id ('Continue existing conversation'), plus a note about unknown extras being ignored. This enhances understanding beyond the schema alone.

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 explicitly states it is a 'Full AI trading assistant powered by GPT' that can analyze markets, compute indicators, fetch live data, place orders, manage positions, and provide strategic advice. This specific verb-resource combination clearly distinguishes it from sibling tools like cc.squirrel_chat (simpler version) and other specialized tools (e.g., cc.twap_executor, cc.strategy_backtest).

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

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

Provides clear guidance: 'Prefer paper/simulation paths. For live money require explicit human confirmation (confirm_live / action=execute).' Also mentions auth, cost, and rate limits. While it doesn't explicitly contrast with every sibling, the context implies this is for conversational trading assistance, leaving specialized tasks to other 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, destructiveHint=false, idempotentHint=true. The description reinforces with 'READ-ONLY. Does not place orders, move funds, or mutate your exchange account' and adds billing, rate limits, and auth details. 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?

The description is comprehensive with clear sections (Behavior, Auth, Cost, Rate limit, Returns, Guidelines). It is front-loaded with the purpose. Slightly verbose but every sentence provides 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?

Given complexity (5 params, output schema exists), description covers behavior, auth, cost, rate limit, output details, and guidelines. It also ties to cc.agent_strategy, completing the workflow context. No 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 coverage is 100% with descriptions for all parameters. The description adds overall context but does not significantly augment parameter meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states it takes a natural language strategy, generates code, and backtests against historical OHLCV data with full simulation. It distinguishes from sibling cc.agent_strategy for paper trading.

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?

Explicit guidelines: 'Compute / parse / backtest only — no live orders' and 'Feed outputs into cc.agent_strategy with force_paper=true to paper-trade.' Provides clear when-to-use vs. when-not-to.

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 explicitly states it is read-only, does not place orders or mutate accounts, adds details on authentication, cost ($0.01 per call), rate limit (20/min), and billing context. This amplifies the annotations (readOnlyHint, destructiveHint, idempotentHint) with concrete 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?

The description is well-structured with clear sections (purpose, behavior, auth, cost, rate limit, returns, guidelines, tags). It is informative but slightly lengthy; however, every sentence earns its place. Could be slightly more concise but not wasteful.

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 complexity and the presence of annotations and an output schema, the description covers all necessary aspects: behavior, authentication, cost, rate limits, return structure, and usage guidelines. It is fully sufficient for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value for the __x_payment parameter by explaining its usage in retries and that it's not a business parameter, going beyond the schema's description. The description parameter's meaning is sufficiently conveyed.

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 parses natural language strategy descriptions into structured executable specifications, listing specific components (timeframes, indicators, etc.). It distinguishes from sibling tools like cc.agent_strategy and cc.strategy_backtest.

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 guidelines: feed outputs into cc.agent_strategy for paper-trading, and states it is for compute/parse/backtest only, not live orders. It implicitly differentiates from execution tools but does not explicitly state when not to use.

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 annotations (destructiveHint=true, readOnlyHint=false), specifies that most calls are read-only but WRITE occurs only when action=execute. Discloses cost, rate limit, and 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?

Well-structured with sections (purpose, behavior, auth, cost, etc.), but slightly verbose. Front-loads purpose effectively.

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?

Covers return format, error handling (HTTP 402), and guidelines. Output schema existence reduces need for return details. Missing 'action' parameter explanation 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?

Schema coverage is 100% so baseline is 3. Description explains idea, risk_pct, __x_payment, but the crucial 'action' parameter (plan vs execute) is not in schema and not fully clarified how to invoke it.

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 takes natural language or structured trade ideas, fetches market context, and generates executable order parameters. Distinct from siblings like cc.twap_executor (execution) and strategy 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?

Explicitly advises to prefer action=plan first, warns that action=execute submits live orders, and requires human confirmation for live money. Also covers auth, cost, rate limits.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description further adds details on caching (15-min), authentication methods, cost per call, rate limit, and explicitly states it is READ-ONLY with no side effects. This goes well 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 verbose and somewhat repetitive (e.g., the live quotes list appears twice). It is well-structured with sections but could be more concise.

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

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

Given the tool's complexity (multiple asset types, payment, caching) and the presence of an output schema, the description covers all essential aspects: what data is returned, authentication, costs, rate limits, caching, and usage guidelines.

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

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

Schema coverage is 100% with one optional parameter (__x_payment). The description adds context that this parameter is for retrying after HTTP 402 when headers cannot be set, which is helpful beyond the schema's description.

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

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

The description explicitly states the tool provides live quotes for a comprehensive list of traditional market assets (S&P 500, Nasdaq, etc.) and distinguishes itself from sibling tools by focusing on traditional finance data.

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

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

The description provides clear guidance: use for research/signal context, pair with cc.agent_strategy before live orders, and warns not to invent fills from this data. It effectively tells when to use and when not to.

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 explicitly states the tool is destructive, submits real exchange orders irreversibly, and is not a simulation. It also clarifies cost as billing (not a side effect) and mentions auth and rate limits, adding context 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 front-loaded with purpose but contains redundancy: the purpose sentence is repeated verbatim. It is longer than necessary, which slightly reduces conciseness.

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

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

Despite having an output schema, the description still explains return values (filled slices, average price, etc.). It covers all important aspects: purpose, behavior, auth, cost, rate limits, guidelines, and tags, making it highly complete for a complex execution 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?

Input schema has 100% description coverage, so baseline is 3. The description adds context for parameters (e.g., 'slices', 'duration_minutes') by explaining the randomization and time window concept, but does not provide deep semantic meaning for each parameter beyond what the schema already offers.

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 is a Time-Weighted Average Price execution engine that splits large orders into randomized slices over time windows to minimize market impact. This specific verb-resource pair distinguishes it from sibling tools, which are primarily data or analysis 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?

Explicit guidelines are provided: prefer paper/simulation paths, require human confirmation for live money, and mention auth requirements and rate limits. This gives clear when-to-use and when-not-to-use advice.

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?

Description explicitly states READ-ONLY, no order placement or fund movement, and mentions billing and rate limits. This adds significant context beyond annotations (readOnlyHint, idempotentHint, destructiveHint).

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

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

Well-structured with front-loaded purpose, then behavior, auth, cost, rate limit, guidelines. Slightly verbose but every sentence adds 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?

Given annotations and output schema existence, description covers purpose, behavior, auth, cost, rate limits, and return type. Complete for a multi-chain RPC gateway.

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

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

Schema coverage is 100% with parameter descriptions. Description adds context for __x_payment (retry after 402) and clarifies that extras are ignored. Adds value beyond schema.

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

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

Description clearly states it's a multi-chain EVM RPC forwarder supporting six chains. It uses specific verbs ('forward', 'call') and distinguishes from sibling RPC tools like Solana RPC.

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 guidance on when to use: preferring eth_call/read methods, and notes that sending raw signed txs is possible but user's responsibility. Lacks explicit when-not-to-use but is clear in context.

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