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

No annotations are provided, so the description carries the full burden. It implies a read-only computation and gives the endpoint shape, but discloses nothing about authentication, rate limits, caching, or what exactly is returned (ATR value, regime label, percentile).

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

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

The core sentence is front-loaded and useful, but the leading phrase is duplicated verbatim after the em dash, which is pure padding. The example is helpful; the redundancy costs a point.

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

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

With no output schema and no annotations, the description should explain the return shape, but it never says what a caller receives (ATR value, regime label, percentile band). For a quantitative endpoint whose whole value is the regime classification, that gap is significant.

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 all four parameters (symbol, period, timeframe, class) are already documented in the schema with defaults and formats. The description's example restates symbol/timeframe/period without adding new semantics, so baseline 3 applies.

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

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

The description names a specific indicator (Wilder's Average True Range) plus an added computation (volatility-regime classification by historical percentile), and scopes it to crypto or stocks. It is clear what the tool produces, but it never distinguishes itself from the sibling 'volatility' tool, which likely overlaps heavily.

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

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

There is no statement of when to reach for this tool versus alternatives such as volatility, ohlcv, or price, nor any prerequisite or context guidance. The only guidance is an example URL, which shows syntax rather than selection criteria.

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

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

With no annotations, the description carries the full burden, and it does add real provenance value: spot from Coinbase, perp marks from Binance + Bybit. It does not mention auth needs, rate limits, or freshness/latency characteristics for a market-data metric.

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

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

The core metric sentence is front-loaded and useful, but the description is literally duplicated before the em dash, which is pure waste. The example line earns its place by showing the call shape.

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

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

No output schema exists, so the description should describe the return shape; it names the quantities (basis/premium %, annualized carry) and data sources, which covers the essentials. It omits units, formatting, and edge cases such as missing perp marks.

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 and schema coverage is 100%, so the schema already explains `symbol` fully. The example (`?symbol=BTC`) reinforces usage but adds no semantics the schema doesn't already carry; baseline 3 applies.

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

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

States a specific computed metric: spot-vs-perp basis (premium %) with funding-implied annualized carry. An agent can distinguish this from plain price or funding_oi lookups. However it offers no explicit sibling differentiation for closely related tools like funding_oi or orderbook.

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

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

No when-to-use or when-not-to-use guidance, and no named alternatives. The only usage signal is the query example, which shows syntax rather than the condition under which this tool beats its siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the call is read-only or triggers a sync/mutation, not auth requirements, not rate limits, not data freshness or normalization semantics despite using the word 'normalized'.

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 body is a verbatim duplication of the same sentence twice, with no front-loaded verb and no additional information in the second copy. That is redundancy rather than concision.

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

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

With no annotations and no output schema, the description is the only source of behavioral and return-shape information, and it provides almost none — not the response structure, not whether results are paginated or per-account keyed. Only the general subject matter is conveyed.

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 reported at 100% for the single user_id parameter, so the schema does the documentation work. The description adds no meaning about user_id scope or how it relates to connected accounts, so the baseline of 3 applies.

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

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

The description names the resource it concerns (cash & buying power per connected account, normalized), which is more specific than the bare tool name. However, it supplies no verb — an agent cannot tell whether this fetches, computes, or pushes/syncs balances — and it does nothing to separate this from siblings like broker_sync_positions or broker_sync_transactions.

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

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

There is no guidance on when to call this versus the other broker_sync_* tools, no prerequisites, and no exclusions. The agent is left to infer usage entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden, yet it only implies read-only via the verb "List." It says nothing about authentication requirements, pagination/result size, rate limits, or what "normalized" entails, all of which matter for a broker-integration read.

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

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

The content is short, but the description literally duplicates itself: the bracketed tag line and the trailing sentence are the same text repeated verbatim. That is pure redundancy rather than front-loaded structure.

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

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

For a one-parameter, read-only list tool with no output schema and no annotations, the description covers the essential "what" adequately. It is minimally sufficient, but omits return shape, pagination, and the meaning of "normalized," which the agent would need for correct interpretation.

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

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

Schema coverage is 100% for the single user_id parameter, so the schema does the documentation work and the baseline of 3 applies. The description's phrase "a user's" lightly reinforces that user_id scopes the result but adds no format or constraint detail beyond the schema.

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

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

The description states a specific verb+resource ("List a user's connected brokerage accounts") and the "(normalized)" qualifier hints at the data shape. It is clear what the tool does and implicitly distinct from siblings like broker_sync_positions or broker_sync_balances, though it never explicitly names those alternatives.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the sibling tools it might be confused with (positions, balances, transactions, register_user). The agent must infer selection from the name alone.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it only discloses that data is normalized and stamped with an as_of timestamp. It says nothing about authentication to brokerages, whether cached or live data is returned, latency, rate limits, or what happens when a brokerage connection is stale or broken.

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 the same sentence duplicated verbatim around an em dash, which doubles length without adding information. Half the text is pure waste, and no structure is used to front-load anything beyond the scope claim.

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

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

For a read-only, single-parameter aggregation tool with no output schema and no annotations, the definition gives the minimum viable picture: it reads positions across brokerages in a normalized form. Missing details on broker connection state, failure behavior, and result shape keep it from being complete.

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

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

Schema description coverage is 100% with a single user_id parameter, so the schema already documents the input. The description adds no format, ID-type, or scoping detail for user_id, which is the correct baseline 3 for a fully documented single-parameter tool.

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

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

The stance 'Real positions across all of a user's connected brokerages, one normalized schema, stamped as_of' states a specific verb and resource and implicitly distinguishes it from siblings like broker_sync_balances and broker_sync_transactions by scope and normal form. It is clear but never names an alternative sibling explicitly, so it falls short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to broker_sync_balances or broker_sync_transactions when the agent wants a different view of the same account. The agent must infer scope from the phrase 'positions' alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not say whether this is a read-only registry lookup or a mutation/sync operation, nor whether it requires auth or hits a live broker endpoint — despite 'live-verified methods' hinting at network behavior worth explaining.

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 the same sentence repeated verbatim twice, which is pure redundancy rather than conciseness. One sentence would have been fine; the duplication is noise an agent must parse through.

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

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

For a zero-parameter tool with no output schema, the description should at least say what the call returns and whether it mutates anything. Instead it only labels the resource, leaving the agent unable to predict the response shape or side effects.

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

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

The tool takes zero parameters (empty object schema), so there are no parameter semantics to document. Baseline 4 applies; the description correctly implies a no-argument call, though it adds nothing further.

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

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

The description identifies the resource — a prop-firm platform integration registry with live-verified methods (Topstep ProjectX, FTMO MatchTrader) and connection status — but it is a noun phrase with no verb, so it never states what the tool actually does. The name suggests a sync action while the text describes a registry, leaving the operation ambiguous.

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

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

There is no when-to-use guidance, no prerequisites, and no reference to any of the many sibling tools it could be confused with (broker_sync_connections, protocol_health_sync_universe, etc.). An agent would have to guess when this registry lookup is appropriate.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully reveals that the call returns a connection-portal URL and that registration happens against an external service (SnapTrade), but it omits idempotency behavior (what happens if user_id already exists), authentication/permission requirements, and whether registration creates lasting side effects.

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 sentence is duplicated verbatim after an em dash, wasting roughly half the text with no added information. The API prefix is front-loaded, but the repetition signals careless authoring rather than deliberate structure.

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

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

With only one parameter and no output schema, the description does cover the essential return value (portal URL), which is the main thing the agent needs. However, it leaves out registration semantics such as duplicate handling and prerequisites relative to sibling broker_sync tools, so it is adequate but not complete.

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

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

Schema description coverage is 100% for the single user_id parameter, which the schema already documents as the application's stable identifier. The description adds no additional semantics about the parameter's format, stability guarantees, or reuse across calls, so the baseline 3 applies.

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

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

States a specific verb (Register) and resource (a user with SnapTrade) plus the outcome (a brokerage connection-portal URL), so the agent knows exactly what the call produces. It does not, however, distinguish itself from sibling tools like broker_sync_connections or broker_sync_positions, which an agent might reasonably confuse with the registration step.

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

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

There is no guidance on when to use this tool versus alternatives, no mention that registration is a prerequisite for the other broker_sync_* tools, and no exclusion criteria. The agent must infer the ordering from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It does not state that this is a read-only lookup, whether results are paginated or capped, what date-range defaults apply when 'from'/'to' are omitted, or whether authentication is per-user. Only the implicit 'history' framing hints that it is 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 a single phrase repeated verbatim after an em dash, which is pure duplication rather than added information. It is short but wasteful, and the front-loaded tag '[Broker Sync API]' conveys namespace rather than capability.

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

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

With no annotations and no output schema, the description must explain both the safety profile and the return shape, and it explains neither. For a three-parameter data-retrieval tool the agent is left guessing about pagination, date-range defaults, and result structure.

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

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

Schema description coverage is 100%, so the schema already documents user_id (required) and the optional from/to date fields with their YYYY-MM-DD format. The description adds no additional meaning, so the baseline of 3 applies.

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

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

The description names a resource (transaction/activity history) and a scope (across brokerages), so an agent can infer what it retrieves. However, it lacks a specific verb and does nothing to distinguish it from close siblings like broker_sync_positions or broker_sync_balances, which are also brokerage-scoped data lookups.

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

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

There is no statement of when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer usage purely from the name and the loosely stated scope.

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

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

With no annotations provided, the description carries the full behavioral burden and largely fails it. It doesn't state that this is a read-only operation, whether auth/keys are required, rate limits, or freshness of the DefiLlama data. Only the implicit read nature can be inferred from the data-retrieval framing.

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

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

The core sentence is repeated verbatim after an em dash ('— DefiLlama data: TVL by chain...'), which is pure duplication and wastes the opening line's value. The example is useful, but the redundant copy is a clear structural flaw and the definition is not front-loaded with an action verb.

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

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

For a zero-required-param data tool with 100% schema coverage but no output schema and no annotations, the description gives adequate orientation (what data categories exist) but omits response shape, pagination behavior of `limit`, and any auth or safety notes. It is minimally sufficient but leaves real gaps.

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

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

Schema coverage is 100%, so the four parameters (view, chain, limit, project) are already fully documented in the schema. The description's mention of the three data categories loosely maps to the `view` values but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

The description names the specific resource and its scope: DefiLlama TVL by chain, stablecoin circulating supply, and yield pools. An agent can identify this as a multi-view DeFi data fetch tool and no sibling (gas, rates, protocol_health_*) covers the same resource. It stops short of a clear verb like 'retrieve', but the resource specificity is strong.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative routing. The only usage hint is the inline example `/v1/defi-tvl?view=chains`, which shows one call form but doesn't tell the agent when this tool is the right choice versus siblings like protocol_health_scoreboard or market_overview.

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

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

With no annotations, the description carries the full burden: it discloses the upstream source ('Sourced live from Nasdaq's public calendar') and the exact payload fields, which is genuinely useful. It omits any mention of auth requirements, rate limits, or freshness/latency guarantees in spite of advertising a 'live' feed.

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

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

The core sentence is duplicated verbatim ('...US equity earnings announcement calendar: report date, before/after-market timing...'), wasting a large share of the text. The useful content (source, example) is present, but the repetition is a clear structural defect.

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

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

For a read-only fetch with full schema coverage and no output schema, the description is adequate: it tells the agent the domain, the source, and the returned fields. It falls short by never disambiguating against the similar macro_calendar sibling or noting any operational constraints.

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 all three optional parameters (date, days, symbol) are already documented with defaults and bounds in the schema. The description adds nothing beyond echoing date/days in the example URL, so the baseline 3 applies.

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

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

The description names a specific resource ('US equity earnings announcement calendar') and enumerates the returned data (report date, timing, EPS estimate + count, market cap, prior-year actual EPS), so an agent knows exactly what it fetches. It does not, however, distinguish itself from the sibling macro_calendar, leaving the boundary between the two calendars unstated.

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

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

There is no when-to-use guidance and no alternative named — notably macro_calendar sits in the sibling list and is never contrasted. The only hint of usage is the embedded example URL, which shows syntax rather than selection criteria.

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

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

With no annotations, the description carries the full burden. It usefully discloses the data sources and derived outputs (7-day average funding, 24h OI change, long/short bias), which tells the agent what is precomputed rather than raw. It does not mention rate limits, auth requirements, latency, or refresh cadence, so it remains incomplete for a read-only aggregate.

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

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

The core sentence is well front-loaded and information-dense, but it is repeated verbatim with no added value, wasting roughly half the description. Trimming the duplicate would make this tight and effective.

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

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

For a single-parameter, annotation-free tool with no output schema, the description compensates by enumerating the returned metrics (funding, 7d average, 24h OI change, long/short bias) and the source venues. Only the absence of usage routing and operational constraints keeps it from a 5.

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

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

Schema coverage is 100% and the single symbol parameter is fully documented in the schema (base symbol mapped to <SYMBOL>USDT perpetual). The description adds no syntax or mapping detail beyond the example, so baseline 3 applies.

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

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

States a specific verb+resource (aggregated perpetual-futures funding rate & open interest) plus the sources (Binance + Bybit) and derived metrics. An agent can distinguish this from siblings like long_short_ratio, basis, or orderbook. The duplicated sentence adds noise but does not obscure the purpose.

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

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

There is no guidance on when to use this versus alternatives. Siblings such as long_short_ratio and basis cover adjacent derivatives metrics, yet the description never names them or states a selecting condition. The example URL gives invocation format but not usage context.

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

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

With no annotations, the description carries the full behavioral burden. It discloses useful traits such as the returned fields, that timeframes match TradingView candles, and the default active-only vs filled behavior (implied by the schema). However it omits auth requirements, rate limits, and pagination/response-shape behavior for a data-fetch endpoint.

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

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

The opening sentence is duplicated verbatim ('Fair Value Gap zones ... distance from price' appears twice), which is wasted space and suggests a generation error. The remaining content is otherwise front-loaded and tight, but the verbatim repetition violates the 'every sentence earns its place' standard.

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

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

For a six-parameter data tool with no output schema and no annotations, the description covers the purpose and partially the return fields, plus an example call. It is adequate but leaves gaps around return shape, pagination, and output units that an agent would want before invoking.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description adds essentially no parameter meaning beyond the schema, aside from the example pairing symbol and timeframe, which earns the baseline 3.

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

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

The description names the concrete resource (Fair Value Gap zones, standard ICT/LuxAlgo) and enumerates the returned fields (CE 50%, gap size, age, fill status, distance from price), which resolves the opaque tool name 'fvg'. It does not, however, distinguish itself from any sibling indicator tool, so it lands at 4 rather than 5.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative routing guidance. It mentions 'Crypto or stocks' and gives a URL example, but never tells the agent how this differs from siblings like liquidity_levels, atr, or ohlcv.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully states that the endpoint is free and requires no signup, identifies the upstream source (Etherscan), and specifies units in gwei, but it does not cover rate limits, error behavior, or explicitly confirm read-only semantics.

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

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

The description is short and front-loads the resource type, but it wastes space by repeating 'Free, no signup required' verbatim in the same sentence. The example path is useful, but the duplication makes it less clean than it could be.

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

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

Given zero parameters and no output schema, the description does a reasonable job by enumerating the returned fields (safe/propose/fast gas prices, base fee) and their unit (gwei). It lacks only minor context such as response shape details or rate-limit expectations.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain. The baseline for a zero-parameter tool is 4, and nothing in the description misrepresents or undermines that.

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

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

The description clearly names the resource and scope: an Ethereum gas oracle returning safe/propose/fast gas prices plus base fee, in gwei, sourced via Etherscan. It is specific enough to distinguish from most sibling data endpoints, though it does not explicitly contrast with any named sibling.

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

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

The only usage context is 'Free, no signup required,' which is access information rather than when-to-use guidance. It never states when to choose this tool over alternatives or what conditions make it appropriate.

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

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

With no annotations provided, the description carries the burden itself. It usefully notes 'Not geo-blocked' and that funding is hourly, which are genuine behavioral traits. It omits auth requirements, rate limits, and whether data is real-time or delayed, so it is only partially transparent.

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

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

The core sentence is duplicated verbatim ('Hyperliquid perpetual context: funding (hourly)...' repeated twice), wasting roughly half the description. The example is useful, but the redundancy is a clear structural flaw.

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

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

For a one-parameter read-only data endpoint with no output schema, the description does list the returned fields, which compensates for the missing output schema. Only the sibling-overlap and auth/pagination details are absent, which are minor for this tool type.

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 a single required 'symbol' parameter that the schema already documents fully with examples. The description adds only the example query string, which restates the same parameter usage rather than adding new semantics.

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

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

The description names the specific resource (Hyperliquid perpetual context) and enumerates the exact data points returned (funding, open interest, mark/oracle/mid price, premium, 24h volume), so an agent knows what it fetches. However, it never differentiates itself from overlapping siblings like funding_oi, price, or orderbook, which cover adjacent 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?

There is no statement of when to use this tool versus the many overlapping market-data siblings (funding_oi, price, ohlcv, basis). The example URL shows a call shape but gives no selection guidance or exclusions.

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

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

With no annotations, the description carries the full burden and discloses key behavioral traits: time-boxed nature (~12s), constrained-generation task, expiration via expires_at, and need for a fresh signed nonce. It does not cover auth requirements or rate limits, but the core timing and prerequisite constraints are present.

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

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

Three sentences, front-loaded with the core action and immediately followed by the next step and prerequisite. Every sentence earns its place with no redundancy.

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

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

Given the tool's complexity, 3 required parameters with full schema coverage, and no output schema, the description adequately covers purpose, timing, and next steps. It could be more complete by describing what the challenge payload looks like (e.g., format of the generation task), but it provides enough for an agent to proceed correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the need for a fresh nonce, but this duplicates the schema's own description ('Nonce from a FRESH identity_get_nonce call') and adds no new semantic detail about the parameters.

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

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

States a specific verb+resource ('Request a real time-boxed liveness challenge') and clearly differentiates from siblings by naming the next step ('Answer via identity_submit_response') and the prerequisite ('Needs a fresh signed nonce'). An agent can distinguish this from identity_get_nonce or identity_submit_response without further investigation.

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 context for when to use it: it must be followed by identity_submit_response before expires_at and requires a fresh nonce from identity_get_nonce. However, it does not explicitly state when not to use it or contrast alternatives beyond the implied flow.

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

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

With no annotations, the description carries the full burden, and it does disclose two real behavioral traits: the nonce is single-use and has a short TTL. However, it omits whether the wallet must already be registered, whether the call is authenticated, and any failure/expiry behavior.

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

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

Two short sentences, front-loaded with the deliverable and then the constraint. Every clause carries information; nothing is padding.

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

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

With no output schema, the description usefully indicates what comes back (a nonce and a message to sign) and its lifetime semantics. It is nearly complete for a single-parameter bootstrap tool, lacking only prerequisite/error context.

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

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

Schema description coverage is 100% and there is only one parameter, so the schema already documents 'wallet' fully. The description adds no additional meaning about the parameter, so the baseline 3 applies.

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

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

States a concrete deliverable (a one-time nonce plus a message to sign) and positions itself as 'Step 1' of a signed-call flow, which distinguishes it from identity_submit_response and identity_get_challenge. It does not explicitly name those siblings, but the resource is unambiguous.

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

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

Clearly states the trigger condition: 'Every signed identity call needs a fresh nonce.' That tells the agent when this tool is required and that it must be re-called per signed operation. It stops short of naming the downstream alternative tools by name.

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

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

With no annotations, the description carries the full behavioral burden, but the operation is a simple zero-parameter public-key fetch. It usefully discloses that the keys are public (no auth secret leaked) and 'Free' (no cost/paywall), yet says nothing about caching, key rotation, or response format.

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

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

Two short fragments, front-loaded with the service name and resource, then the purpose and cost. Nothing is wasted, though the telegraphic style makes it slightly clipped rather than fully self-explanatory.

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

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

For a zero-parameter, no-output-schema key retrieval, the description supplies enough to call it correctly: what it returns, why, and that it is free. The main omission is any hint about the response shape (standard JWKS), which an agent could reasonably assume.

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

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

The tool takes zero parameters, so the baseline is 4. The description adds no parameter detail because none is needed, and the empty schema is consistent with the 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 clearly states the resource returned (public RS256 keys) and the resource's purpose (verify an assertion_token locally). It distinguishes itself from other identity_* siblings, which handle nonces, registration, and challenges. It lacks an explicit verb like 'returns' or 'fetches', but the resource is unambiguous.

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

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

The phrase 'to verify an assertion_token locally' implies the use case (offline token verification), which is a fair contextual hint. However, it does not state when to prefer this over server-side verification or reference any sibling tool, leaving usage to inference.

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

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

With no annotations, the description carries the full burden and does well: it discloses the auth model ('needs your signature'), the no-stake constraint, and a key safety fact ('this tool never signs'), which corrects the common assumption that a register tool might sign on the user's behalf. It omits post-registration behavior and error handling, keeping it from a 5.

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

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

Two sentences, purpose front-loaded, then the dependency and safety note. No filler; every clause survives deletion as necessary information.

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

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

For a 3-param mutation with no annotations and no output schema, the description covers purpose, prerequisite, and the auth/never-signs behavioral model adequately. It leaves unaddressed what a successful registration returns and whether the nonce is single-use, minor gaps given full schema coverage.

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

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

Schema description coverage is 100% and each parameter is already documented (wallet on Base, nonce freshness, 0x-prefixed ECDSA signature). The description only reinforces the nonce/signature relationship rather than adding new syntax or format detail, so the baseline 3 applies.

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

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

Specific verb+resource: 'Register your wallet', plus a scope qualifier ('no stake required') and a named sibling dependency (identity_get_nonce). An agent can immediately tell this is the wallet-registration step of the identity flow, distinct from identity_get_nonce/submit_response/status.

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?

States the prerequisite clearly: you must first call identity_get_nonce and sign its message, and the nonce must be fresh. It tells the agent what to do before invoking but does not discuss alternatives or when-not-to-use (e.g., when already registered), so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses that no signature is required and the two accepted auth mechanisms (x402 or IDENTITY_API_KEY), which is genuine behavioral context. It does not describe return shape, failure modes, or 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?

Three short, front-loaded sentences with zero filler; the auth note follows the core purpose immediately and nothing is redundant.

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

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

For a single-parameter read-only status check with a fully documented schema and no output schema, the description is nearly complete: it conveys the question answered and the auth requirement. Only the boolean/status return nature could be stated more explicitly.

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

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

Schema coverage is 100% and the single 'wallet' parameter is fully documented in the schema. The description references 'a wallet' but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description states a specific question the tool answers ('Does a wallet currently hold a valid, unexpired assertion?'), which is a clear verb+resource purpose. It distinguishes itself by nature from check-style siblings, but never explicitly names alternatives like identity_get_challenge or identity_submit_response.

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

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

'No signature needed. x402 or IDENTITY_API_KEY.' signals when/how it can be called, implying a lightweight read that does not require the signature flow of other identity tools. However, it gives no explicit when-to-use versus alternatives and no exclusions.

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

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

With no annotations, the description carries the full burden and does disclose key behavior: the outcome is scored pass/fail/inconclusive, and a pass returns a short-lived signed assertion_token (JWT) verifiable via identity_jwks. It also flags the nonce-freshness constraint. It does not cover retry/one-shot semantics or failure consequences, keeping it below 5.

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

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

Three tight clauses: what it does, what a pass yields, and the nonce prerequisite. The scoping and workflow-critical constraint are front-loaded, and nothing is padding.

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

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

For a 5-required-param tool with no annotations and no output schema, the description explains the outcome states and the returned token, which is what an agent most needs. It omits signing/auth expectations and failure handling, but those are partially covered by the schema field descriptions.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a constraint the schema does not state explicitly: the nonce must be DIFFERENT from the one identity_get_challenge used. That extra rule meaningfully improves correct invocation of the nonce parameter.

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

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

The description states a specific verb (submit) and resource (your answer to a challenge), and adds the scoring semantics (pass / fail / inconclusive). It names sibling tools (identity_get_challenge, identity_jwks, identity_get_nonce), so an agent can place it in the identity workflow without opening other schemas.

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

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

It references the surrounding flow (the nonce must differ from the one identity_get_challenge used) and points at identity_get_nonce as the nonce source, which tells the agent when this step applies. There is no explicit 'when not to use' or fallback alternative, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a read-only data fetch and gives a sample URL, but discloses nothing about auth requirements, rate limits, pagination, or how the orderbook/trades payload is shaped. Significant gaps remain for a tool with zero annotation coverage.

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

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

The purpose is front-loaded and the example URL is useful, but the opening sentence is duplicated verbatim ('— Single Kalshi market depth...' repeated), which is pure waste. Size is otherwise short and appropriate.

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

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

For a three-parameter read tool with 100% schema coverage and no output schema, the description is adequate to call it correctly. However, it could have explained the structure of the orderbook/trades response since no output schema exists, and it lacks usage context, leaving it minimum-viable.

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

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

Schema description coverage is 100%, so the schema already documents depth, ticker, and trades fully, including defaults and max values. The description adds no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.

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

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

The description names a specific resource (a single Kalshi market) and the exact data returned (orderbook yes/no levels plus recent trades) for a given ticker. It is clearly distinguishable from kalshi_probability, but it never explicitly differentiates itself from the generic 'orderbook' sibling, leaving some ambiguity.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternatives. An agent gets no help deciding between this tool, kalshi_probability, or the generic orderbook sibling for a given request.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose useful context — free, no signup required (no auth needed) and that category queries return the most active open markets. It says nothing about pagination, rate limits, error behavior, or the shape of a probability result, leaving meaningful gaps for a data tool.

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

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

The core sentence and example are front-loaded and useful, but 'Free, no signup required' is duplicated verbatim in the first line, which is pure waste. Removing the repetition would make this tight.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral and return-value context. It gives a partial picture of returns ('most active open markets') and access terms, but omits result fields and constraints an agent would want before calling.

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

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

Schema description coverage is 100%, so the schema already documents limit, ticker, and category (including the enumerated category values and the required-either constraint). The description merely restates the category/ticker axis and adds no format or constraint detail beyond the schema, so baseline 3 applies.

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

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

The description states a specific verb and resource: querying Kalshi prediction-market probabilities, with the two supported query modes (category vs. ticker). It also notes what a category query returns (most active open markets). However, it never distinguishes itself from the sibling kalshi_market tool, so an agent must guess which to pick.

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

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

It implies usage via 'Query by category ... or a specific market ticker' and the example call, so the two modes are discoverable. But there is no explicit when-to-use guidance, no when-not-to-use, and no routing to the kalshi_market sibling that overlaps this domain.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints at output content (sweep/taken status, pools, untaken targets) but says nothing about authentication, rate limits, payload size, or how the levels are returned. For a data tool with zero annotation coverage, this is a substantial gap.

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

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

The core sentence is stated twice verbatim, wasting roughly half the description and pushing the useful example further down. The example is well placed, but the duplication is a clear structural defect that undermines front-loading.

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

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

With all parameters documented in the schema and no output schema, the description only needs to cover purpose and routing. It covers the domain concepts well but omits sibling differentiation and any behavioral context, leaving it just barely sufficient for a six-parameter data endpoint.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including defaults and ranges (lookback default 300 max 500, timeframe default 1h, swing_length default 5). The description adds only the example invocation with symbol and timeframe, so the baseline of 3 applies.

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

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

The description names a specific resource (ICT liquidity levels) and enumerates the exact content: buy-side liquidity above swing highs, sell-side below swing lows, sweep/taken status, relative-equal pools, and nearest untaken targets. It also notes the asset coverage (crypto or stocks). It does not, however, distinguish itself from closely related siblings such as fvg, ohlcv, or atr, which an agent could plausibly confuse it with.

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

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

Usage is only implied through the example URL (`/v1/liquidity-levels?symbol=TQQQ&timeframe=1h`), which shows a concrete call pattern. There is no explicit statement of when to prefer this over fvg or ohlcv, and no prerequisites or exclusions are given. Adequate but leaves routing decisions to inference.

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

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

No annotations are provided, so the description carries full burden. It reveals nothing about auth requirements, rate limits, latency, or whether data is historical vs live; only a sample request URL is given. For a data-fetch tool with zero annotation coverage this leaves real gaps.

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

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

The opening clause is duplicated verbatim ('Binance long/short ratios: global account, top-trader account, top-trader position, and taker buy/sell' appears twice), wasting half the description. The example URL is useful, but the restating hurts front-loading.

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

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

No output schema exists, and the description does not describe the shape of the returned ratio data, so an agent can't anticipate the response. Params are covered by the schema and an example is provided, making it minimally adequate for a simple 2-parameter read tool.

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

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

Schema description coverage is 100% – both symbol and period are fully documented in the schema, including the period enumeration and the <SYMBOL>USDT mapping. The description's example URL adds usage syntax but no semantic detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb/resource: retrieving Binance long/short ratios, and enumerates the four variants (global account, top-trader account, top-trader position, taker buy/sell). Clear what the tool fetches, but no explicit differentiation from siblings beyond the 'companion to funding-oi' note.

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

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

No guidance on when to use this versus alternatives like funding_oi, sentiment, or orderbook. The 'Companion to funding-oi' line hints at a pairing but doesn't state a condition or exclusion.

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

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

With no annotations, the description carries the full burden but does add useful context: no signup/auth required, data provenance (verified Fed/BLS dates), and the inclusion of Kalshi probability data. It still does not disclose read-only nature explicitly, rate limits, caching, or timezone/date-range behavior for 'upcoming'.

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 lead is front-loaded and informative, but the sentence opens with 'Free, no signup required — Free, no signup required', a verbatim duplication that wastes space. The example path is mildly useful but not essential.

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

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

With no output schema and no annotations, the description does the heavy lifting by enumerating the returned fields (dates, days-until, odds) and the covered event types. It is nearly complete — only the absence of any usage/prerequisite guidance for the filtering parameters keeps it from a 5.

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

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

Schema coverage is 100% and both parameters (days, type) are documented in the schema, so the baseline of 3 applies. The description implies date-window and event-type filtering implicitly through 'days-until' and the event list, but adds no syntax or enum detail 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?

States a specific resource (upcoming US macro events — FOMC, CPI, NFP) and the payload it returns (verified Fed/BLS dates, days-until, Kalshi cut/hold/hike odds), so an agent knows exactly what it gets. It does not, however, explicitly distinguish itself from the similarly named earnings_calendar sibling, so it falls short of a 5.

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

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

There is no when-to-use guidance, no mention of alternatives (e.g. earnings_calendar or kalshi_market for the odds component), and no prerequisites beyond 'free, no signup required'. The example endpoint is descriptive, not selective.

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

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

With no annotations, the description carries the full burden. It discloses the data source (Alpaca) and that the tool is scoped to equities rather than crypto, and the read-only nature is clear from 'clock'. It omits any mention of auth requirements, rate limits, failures at session boundaries, or timezone semantics for next_open/close.

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

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

The core sentence is repeated verbatim ('US equities market clock (is_open, next_open/close) + upcoming sessions, via Alpaca' appears twice), wasting roughly half the text. The endpoint example and the crypto caveat are useful, but the duplication is a structural defect in an otherwise short description.

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

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

With no output schema, the description must convey the return shape, and it does list the key fields (is_open, next_open/close) plus upcoming sessions. It does not explain the structure of the upcoming-sessions array or how next_open/close are formatted, so an agent still has gaps for a data-returning 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 a single optional parameter with 100% schema description coverage, including default, max, and the 0-to-omit behavior, so the description adds nothing beyond the schema. Baseline 3 applies when the schema already does the work.

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

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

The description names a specific resource (US equities market clock) and enumerates the returned fields (is_open, next_open/close) plus upcoming sessions, with the data provider (Alpaca) identified. It does not name or distinguish itself from any sibling tool, but no sibling in the list covers market session timing, so the purpose is unambiguous.

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

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

The note that 'Crypto endpoints are 24/7 and unaffected' implicitly scopes usage to US equities sessions, which helps an agent decide when this tool applies. However, there is no explicit when-to-use/when-not-to-use guidance or alternative routing, and the sibling list contains no direct competitor to point at.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one genuine behavioral trait — no auth/signup needed — but says nothing about rate limits, data freshness/caching, or whether the two views return different shapes.

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

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

Front-loads the API tag and the free/no-signup claim, which is good, but 'Free, no signup required' is literally duplicated, and the bare example path adds little for an agent that already knows the tool name. Padding costs it a point.

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

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

For a 2-parameter, read-only, zero-required-arg tool with a fully documented schema, the description covers purpose and auth adequately. With no output schema and no annotations, however, it should say something about the shape of the returned data or refresh cadence and does not.

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 both parameters (view, limit) are already documented with defaults and maxima in the schema. The description's mention of 'global stats or top coins' loosely maps to the view parameter but adds no syntax or constraint detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific resource and content: CoinGecko global crypto stats (market cap, 24h volume, BTC/ETH dominance) or top coins by market cap. An agent can distinguish this aggregate-market tool from siblings like price, ohlcv, or sentiment, though it never names a sibling explicitly.

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

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

No when-to-use guidance, no conditions for picking this over price/ohlcv/sentiment, and no prerequisites beyond 'no signup required'. The agent must infer usage entirely from the purpose sentence.

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

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

With no annotations, the description carries the full burden and does well: it declares irreversibility ('PERMANENTLY'), explains what is destroyed (all versions by default), and what is retained (an audit row with no content). It omits auth/permission requirements and the response shape, keeping it short of a 5.

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

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

Three tight sentences, front-loaded with the destructive nature and scope default; every sentence carries information. The '[Wicked Memory]' prefix is the only minor overhead.

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

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

For a destructive tool with no output schema and no annotations, the description covers permanence, scope defaults, and retention policy. It lacks any mention of the signature/nonce authorization flow or error behavior, but is otherwise sufficient to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including the scope enum-like values. The description reinforces scope behavior but adds no new syntax or format detail beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('PERMANENTLY hard-delete a memory') with clear scope semantics, and the 'right-to-be-forgotten' framing distinguishes it from softer siblings like memory_update or memory_deletions. An agent can identify it as the destructive memory operation without ambiguity.

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

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

The description explains the scope parameter's default and effect, which is genuine usage guidance, but it never states when to prefer delete over memory_update or what prerequisites (signature/nonce flow) are needed. Usage is implied rather than explicit, with no alternatives named.

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

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

With no annotations, the description carries the full burden, and it does disclose one meaningful behavioral trait: the log never contains content, only metadata. However, it omits that this is a read-only operation, the authentication/signature requirement implied by the wallet/nonce/signature params, and any pagination or scope 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?

A single tightly written sentence that front-loads the tool's identity and then its contents. No filler, though it is brief enough that it could have afforded one clause of usage guidance.

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

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

For a read tool with no output schema, the description usefully sketches the return shape (ids, times, reasons, never content), and the auth parameters are fully documented in the schema. It is nearly complete, missing only explicit usage routing and the read-only characterization.

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

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

Schema description coverage is 100%, and each parameter is documented in the schema, so the baseline is 3. The description adds no parameter-level detail; 'ids, times, reasons' describes return values rather than inputs.

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

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

The description names a specific resource ('deletion audit log') and enumerates its contents (ids, times, reasons; never content), which is enough to distinguish it from the general memory_history sibling. It stops short of explicitly contrasting itself with memory_history or memory_delete, so it is clear but not fully differentiated.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to the closely related memory_delete/memory_history tools. The agent must infer that this is the read-side counterpart of deletion operations.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely non-obvious behavior: another wallet's memory and a deleted id both return an identical 404, so the tool cannot be used to probe for existence. It stops short of describing the return payload (no output schema) or the memory_prepare/signature prerequisite, so gaps remain.

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

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

A single sentence with the resource and lookup key front-loaded and the error semantics appended without wasted words. Nothing could be trimmed without losing information.

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

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

For a five-parameter, all-required tool with no output schema, the description leaves the return shape undefined and omits the memory_prepare prerequisite workflow entirely. It covers identity scoping and error behavior adequately but is thin on what the agent actually receives back.

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%, including the cross-reference that nonce/timestamp/signature come from memory_prepare, so the schema already does the work. The description adds nothing about parameter format or the single-use nature of the nonce beyond what is structured.

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

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

States a specific verb and resource ('Fetch one of your memories by id'), which cleanly separates it from memory_search, memory_history, and memory_delete in the sibling list. The parenthetical adds the key scope constraint that only own, non-deleted ids resolve.

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

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

Usage is implied by 'by id' – the agent can infer this is the direct-lookup counterpart to memory_search – but no alternative is named and no when-not condition is stated. It never says to prefer memory_search when the id is unknown.

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

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

With no annotations, the description carries the full burden, and it does disclose the return ordering and the temporal/supersession fields the chain contains. However it says nothing about the read-only nature of the call, pagination, or whether chains can be long, so behavioral coverage is partial.

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

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

A single sentence, front-loaded with the resource and return shape, with zero filler. Every clause (chain scope, ordering, returned fields, id flexibility) earns its place.

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

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

For a read-only lookup with no output schema, the description adequately explains what comes back (full chain, ordering, temporal fields) and how to address it. Minor gaps remain around pagination or chain-size limits, but nothing essential to calling it correctly is missing.

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

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

Schema description coverage is 100% and the schema already states memory_id is "UUID of any version in the chain," so the description's note that it works from any version's id adds little beyond the structured field. 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?

States a specific verb+resource: it returns the full version chain for a memory, with concrete returned fields (valid_from/valid_until/superseded_by) and ordering (oldest first). It is distinguishable from memory_get/search by describing a chain rather than a single record, though it never names those siblings explicitly.

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

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

"Works from any version's id" is the only usage signal, and it usefully tells the agent it need not supply the root version. There is no explicit when-to-use-this-vs-memory_get guidance or mention of prerequisites, so usage is only implied.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the signing scheme (EIP-191 personal_sign), the ephemeral 5-minute timestamp window, and the single-use nonce that forces a fresh prepare for every call. These are exactly the behavioral traits an agent must know before invoking, none of which appear in structured fields.

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

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

Three sentences, front-loaded with purpose and the critical 'prepare again for every call' constraint. Every clause adds actionable information with no repetition.

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

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

For a negotiation/prepare tool with no output schema, the description states what is returned (message_to_sign plus timestamp and nonce) and the full signing protocol. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real meaning: `operation` selects which memory_* tool will be called, and `params` are the arguments forwarded verbatim to that tool, which the schema only hints at. It does not enumerate the operation-to-tool mapping values, but the schema's enum-style list covers that.

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

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

States a specific verb and resource: returns the exact `message_to_sign` for the Wicked Memory signing flow, and its position as 'step 1 of every call'. It is unmistakably distinct from the memory_store/search/get/update/delete siblings it feeds into.

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 when-to-use and sequencing: sign the message with EIP-191 personal_sign, then call the matching memory_* tool with the SAME arguments plus the returned timestamp, nonce and signature. It also states the operating constraints (timestamp within 5 minutes, single-use nonce, re-prepare for every call), leaving no inference required.

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

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

With no annotations, the description carries the full burden and does so well: it discloses metering, the exact 402 http_status behavior, the x402 v2 payload location, the price and network (0.001 USDC on Base), and the non-obvious retry semantic that a 402 does not consume the nonce. That is precisely the behavioral context an agent cannot infer from the schema.

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

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

Two tight sentences, purpose front-loaded, payment mechanics second. No wasted words while still conveying the retry constraint.

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

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

For a 12-parameter, 5-required tool with no output schema, the description covers the payment/auth behavior thoroughly. It stops short of describing the prepare-then-search prerequisite chain and the shape of search results (matching, ranking, pagination), which are the remaining gaps.

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

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

Schema description coverage is 100%, so all 12 parameters are documented in the schema itself; the baseline is 3. The description only ties payment_signature to the 402 retry flow, adding marginal meaning beyond that, and explains none of the other parameters.

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

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

States a specific verb and resource: 'Semantic search over YOUR memories only, ranked by real cosine similarity.' The 'YOUR memories only' scoping and cosine-similarity ranking distinguish it from sibling reads like memory_get or memory_history, though it never names them explicitly.

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

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

Gives strong guidance on the paid invocation path (free with MEMORY_API_KEY, otherwise pay and retry with the SAME arguments plus payment_signature), but gives no guidance on when to choose this over sibling tools such as memory_get or memory_history, nor that memory_prepare must run first to obtain nonce/timestamp/signature.

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

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

No annotations are provided, so the description carries the full burden. It discloses the rate-limit scheme ('free, fair-use rate limited') and a behavioral trait beyond the schema ('a real embedding is computed at write time'), which is meaningful context for a write operation. It does not state durability, whether writes are idempotent, or what the response contains, but the annotation-free gaps are partially covered.

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

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

Two compact sentences that front-load the purpose and immediately follow with the precondition. The '[Wicked Memory]' prefix is mildly redundant with the tool name, keeping it from a 5, but there is no waste otherwise.

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

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

For an 8-parameter write tool with no annotations and no output schema, the definition covers the critical cross-tool precondition and the embedding side effect. It does not explain the return value or failure modes (e.g., nonce reuse, signature mismatch), but the schema and the memory_prepare reference fill most of the gap.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters including the memory_prepare-derived nonce, timestamp, and signature. The description adds only the cross-tool instruction to fetch these from memory_prepare, which is moderately useful but not new field syntax. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Store a memory') and distinguishes itself from siblings like memory_search/memory_get/memory_update. The bracket-prefixed namespace and 'a real embedding is computed at write time' further pin down what happens, so an agent can tell this is the write path of the memory family without opening schemas.

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

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

The description gives a concrete required precondition: 'Run memory_prepare with operation "store" and these same arguments first.' That is a clear when-to-use signal and names the sibling to call beforehand. It stops short of saying when NOT to use it (e.g., instead of memory_update for existing records), so it falls just below a 5.

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

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

With no annotations, the description carries the full burden and discloses key mutation semantics: creates a new version, closes the old one via valid_until/superseded_by, omitted fields carry over, and a 409 error if updating a non-current version. It does not mention auth requirements (nonce/signature from memory_prepare) or rate limits, but those are covered by the schema.

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

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

Two sentences with zero waste. The versioning differentiator is front-loaded, followed by the carry-over rule and error condition, making the key behavior immediately clear.

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

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

For a versioned mutation tool with no output schema and no annotations, the description covers versioning, partial updates, and error conditions well. It omits any mention of the return value (e.g., the new version ID) and does not reference the memory_prepare dependency, though the schema documents the nonce parameter.

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 meaningful semantics beyond the schema by stating that omitted fields carry over, clarifying partial-update behavior for content, tags, metadata, and source.

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

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

The description states a specific verb (update) and resource (memory), and immediately clarifies the non-overwriting versioning behavior, distinguishing it from memory_store (which creates new memories) and memory_delete.

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

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

The description implies usage by explaining versioning and the constraint that only the current version can be updated (409 otherwise). However, it does not explicitly name alternatives like memory_store or memory_delete, nor does it state when-not-to-use conditions beyond the current-version restriction.

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

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

With no annotations, the description carries the full burden, and it does add two useful facts: the verdict is produced by the oracle.py pipeline on a separate Python service, and the tool is scoped to 10 assets. But it says nothing about latency, auth requirements, rate limits, staleness of the verdict, or failure behavior for an out-of-scope symbol.

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

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

The core sentence is duplicated almost verbatim, wasting roughly half the text. The pipeline/scoping detail is buried inside that copy instead of being front-loaded, and the only unique content (the example) sits at the end.

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

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

There is no output schema, so the description must carry return-value information — and it does enumerate the verdict fields, which is genuinely helpful. But it omits how to interpret the verdict (signal thresholds, confidence scale) and gives no usage context, leaving the definition only minimally complete for an analytics tool.

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

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

Schema description coverage is 100% and both parameters are self-documenting (enumerated symbol set, typical timeframe values with default). The description's example query restates the parameters but adds no semantics beyond the schema, which is the expected baseline.

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

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

The description names a specific resource (momentum verdict) and enumerates its outputs (bias, confidence, thesis, entry/invalidation/targets, signal readings), so an agent can tell it is a momentum-analytics tool rather than a raw price feed. However, it never distinguishes itself from momentum-adjacent siblings like funding_oi, long_short_ratio, or sentiment, and the statement is delivered twice.

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

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

There is no guidance on when to reach for this tool versus sentiment, ohlcv, atr, volatility, or the other analytics siblings. The only usage hint is a URL example showing symbol/timeframe parameters, which shows how to call it but not when.

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

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

With no annotations present, the description carries the full burden. It does disclose two useful traits — result ordering (oldest-first) and upstream routing (Alpaca SIP / Alpaca-crypto / Coinbase) — but says nothing about auth requirements, rate limits, symbol-not-found error behavior, or what happens when limit exceeds the max of 300.

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 first clause is duplicated verbatim ('OHLCV candles (oldest-first) for crypto or stocks' twice), which is pure waste. The example call is genuinely useful and the routing sentence is short, but the repetition undercuts an otherwise tight definition.

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

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

No output schema exists, so the description should characterize the return payload, yet it never enumerates the candle fields (open/high/low/close/volume/timestamp) or the response envelope. Ordering is covered; shape and error cases are not.

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 symbol, timeframe, limit, and class are already fully documented with defaults and ranges. The example URL reinforces format but adds no semantics beyond the schema. Baseline 3 applies.

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

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

States a specific resource (OHLCV candles) and a distinguishing attribute (oldest-first, crypto or stocks), which is more than the name alone conveys. However it does not differentiate from the sibling `price` tool, which likely returns a current quote, leaving overlap unaddressed.

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

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

There is no guidance on when to use this versus `price`, `orderbook`, or `volatility` — all close siblings in the same market-data family. The mention of routing to Alpaca/Coinbase is implementation detail, not a use-condition.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing: no auth requirements, no rate limits, no data freshness/refresh semantics, and no statement of what is returned beyond 'depth + spread'. The 'spread (bps)' unit is the one genuinely useful behavioral detail.

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

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

The core sentence is repeated verbatim before the example, so roughly half the text is dead weight. Front-loading is fine, but the duplication makes the definition look unedited rather than deliberately concise.

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

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

For a no-annotation, no-output-schema market-data tool, the description should at least describe the shape of the response (bid/ask levels per side, spread in bps) and any limits. It stops at a one-line summary plus an example, leaving the agent to guess at return structure and freshness.

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 symbol, exchange, and depth (default 10, max 50), which sets the baseline at 3. The embedded example URL restates the same parameter names without adding format or constraint detail beyond the schema.

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

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

The description names a concrete resource (top-of-book depth and spread in bps) and the supported venues (Binance, Bybit, Hyperliquid), so the agent knows what data comes back. However, it never distinguishes this from close siblings such as price, ohlcv, or liquidity_levels, and the sentence is literally duplicated, which wastes the strongest positioning slot.

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

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

There is no when-to-use guidance at all — nothing says to prefer this over price/ohlcv when the agent needs current bid/ask imbalance or spread rather than candles. No exclusions, prerequisites, or alternatives are named despite a large sibling set covering adjacent market data.

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

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

With no annotations, the description carries the full burden and does well: it discloses that settlement is USDC direct to payTo, that upstreamUrl proxies paid requests to a backend, that changes go live in ~20s, and that PAYWALL_API_KEY is required. It does not describe reversibility or the response, but the operational profile is unusually well surfaced for an unannotated tool.

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

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

Three tight sentences, zero filler, front-loaded with the core action followed by settlement/proxy behavior and then the timing/auth constraint. Every sentence carries distinct information.

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

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

For an 8-param create tool with no annotations and no output schema, the description covers purpose, side effects, latency, auth, and settlement flow. The only gap is return-value/confirmation behavior, which is minor since no output schema is declared.

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, but the description adds meaning beyond the schema by explaining what upstreamUrl actually does (proxies paid requests to your backend) and confirming USDC settlement to payTo. This clarifies the two most consequential params rather than merely restating them.

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

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

States a specific verb and resource: 'Paywall a new endpoint with x402 pay-per-call.' The 'new endpoint' framing distinguishes it from paywall_update_route/paywall_delete_route/paywall_list_routes, but it never names those siblings explicitly.

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

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

There is no explicit when-to-use guidance and no reference to alternatives such as paywall_import_routes or paywall_update_route. The agent must infer the create-vs-update-vs-import choice from the name alone, and nothing states prerequisites or exclusions beyond the API key note.

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

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

With no annotations, the description carries the full burden. It usefully discloses the ~20s propagation delay and that PAYWALL_API_KEY is required, which is real behavioral context beyond the schema. However, for a destructive operation it omits irreversibility, confirmation requirements, and effects on in-flight traffic.

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

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

A single front-loaded sentence with zero waste: purpose first, followed by the two operational caveats. Appropriately sized for a one-parameter tool.

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

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

For a tool with no output schema and no annotations, the description covers the essential calling context: what it does, the auth requirement, and the propagation timing. It stops short of addressing destructive/irreversible semantics, which a delete tool could reasonably note.

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%; the sole parameter is documented as 'Route id from paywall_list_routes'. The description adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Remove a paywalled route') and clearly distinguishes itself from siblings like paywall_create_route, paywall_update_route, paywall_import_routes, and paywall_list_routes. An agent can select it without ambiguity.

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

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

Usage is implied by 'Remove a paywalled route' and the schema's reference to paywall_list_routes as the id source, but there is no explicit when-to-use versus alternatives (e.g., update vs delete) or precondition guidance. Adequate but not instructive.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one genuinely useful fact outside the (empty) schema: the call requires PAYWALL_API_KEY. However, it says nothing about whether the operation is read-only, what the tenant record contains, or how auth failures surface.

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

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

A single short sentence with the grouping tag '[x402 Paywall]' front-loaded and the auth prerequisite appended. Nothing is wasted, though the terse phrasing leaves the reader with only a name-level understanding.

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

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

With no output schema and no annotations, the description is the only source of information about this call, and it stops short of describing what a tenant record contains or what happens on a missing/invalid key. Adequate for a zero-parameter read, but thin for a tool whose output shape is otherwise undocumented.

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

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

The tool takes zero parameters, so there is no parameter semantics to convey; the baseline for a parameterless tool is 4. The description correctly implies no inputs are required.

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

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

States a specific verb (get) and resource (tenant record) and adds the scoping word 'Your,' clarifying this returns the caller's own tenant rather than an arbitrary one. It is clear but offers no explicit differentiation from the other paywall_* siblings beyond the resource name.

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

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

There is no when-to-use guidance, no mention of alternatives, and no conditions under which this should or should not be called. The only guidance is the parenthetical prerequisite '(needs PAYWALL_API_KEY)', which is a requirement rather than usage direction.

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

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

With no annotations, the description carries the full burden and does disclose the two most important traits: PAYWALL_API_KEY is required, and upsert is keyed on (method, path). It does not say whether routes omitted from the payload are deleted or preserved, nor anything about error/partial-failure behavior, which matters for a bulk mutation.

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

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

One sentence, front-loaded with the tag, verb, key, and payoff, with the auth caveat appended compactly. No wasted words.

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

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

For a one-param bulk mutation with a fully covered schema and no output schema, the description covers purpose, auth, and keying adequately, but leaves the critical merge-vs-replace semantics and return behavior unaddressed.

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

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

Schema description coverage is 100% and the single 'routes' parameter is fully documented field-by-field, so baseline 3 applies. The description's keying note adds minor meaning but does not extend the per-field documentation.

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

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

States a specific verb (bulk upsert) and resource (routes) plus the keying semantics (method, path), and 'paywall a whole API in one call' cleanly distinguishes it from the single-route siblings paywall_create_route and paywall_update_route.

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?

'Bulk upsert ... a whole API in one call' clearly signals the context (many routes at once) and names the auth prerequisite, but it never explicitly routes the agent to paywall_create_route/paywall_update_route for single-route cases.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses the authentication requirement (PAYWALL_API_KEY), which is real behavioral context, but says nothing about scope of results, pagination, or filtering. A read operation is implied but not stated.

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

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

A single compact sentence with the namespace tag front-loaded and the auth caveat in parentheses. Efficient, though the namespace bracket is somewhat redundant with the tool name prefix.

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

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

For a no-parameter, no-output-schema listing tool, the description covers the essentials: what it returns and that it needs an API key. It could add whether it returns all routes and in what form, but little else is missing.

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

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

The tool takes zero parameters, which is the baseline 4 per the rubric. The empty schema leaves nothing to document, so no compensation is required.

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

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

States a specific verb+resource ('List your paywalled routes') and namespaces it under x402 Paywall. It is distinguishable from siblings like paywall_list_settlements by the 'routes' resource, though it does not explicitly contrast them.

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

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

There is no explicit when-to-use guidance or routing against alternatives such as paywall_create_route or paywall_list_settlements. The reader must infer that this tool retrieves the user's registered routes.

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

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

With no annotations, the description carries the full burden, and it does disclose the auth requirement and that data is real on-chain USDC settlement records. It does not state pagination behavior, ordering, or whether results are read-only (implied by 'list' but not stated), leaving notable gaps for an annotation-free tool.

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

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

A single compact sentence with the module tag front-loaded and the auth caveat trailing. It is appropriately sized, though the parenthetical '(earnings)' is slightly redundant with 'USDC settlements'.

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

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

No output schema and no annotations, so the description should do more, e.g., describe the returned settlement shape or pagination. For a simple one-param list endpoint it is barely adequate but leaves the read semantics and result format to inference.

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

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

Schema description coverage is 100% with a single 'limit' param that the schema already documents as 'Default 50, max 200'. The description adds nothing beyond the schema, so the baseline 3 for full coverage is appropriate.

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

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

The description states a specific resource ('real on-chain USDC settlements') and clarifies them as 'earnings', so an agent understands this returns settlement data rather than routes or tenant config. However, the listing/aggregation verb is only implied by the name, and it doesn't explicitly distinguish itself from paywall_list_routes beyond the resource noun.

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 only guidance is the prerequisite '(needs PAYWALL_API_KEY)', which is helpful for auth. There is no statement of when to use this versus other paywall list endpoints, nor any conditions on when not to call it.

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

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

With no annotations, the description carries the full burden and delivers strong disclosures: the key is returned ONCE (a non-recoverable, effectively non-idempotent output) and the call is rate-limited to 5/hour per IP. It stops short of stating what happens on duplicate name/slug or whether the account is immediately active, so it is not fully transparent.

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

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

Three tight sentences, front-loaded with purpose, then the critical return-value caveat, then the rate limit. Zero waste; each clause carries actionable information.

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

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

For a 2-param, no-output-schema tool, the description covers the one return value an agent must know (the one-time apiKey) and the operational limit. It lacks error/conflict behavior and any note on whether credentials are required, which is a minor but real gap given there are no annotations to fall back on.

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

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

Schema description coverage is 100%, and the schema itself documents both name and slug constraints including the slug-to-mount-path mapping. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Create a tenant account') and scopes it with the [x402 Paywall] prefix, clearly distinguishing it from the read-side sibling paywall_get_tenant. An agent can tell immediately this is the account-provisioning tool.

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

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

Usage is implied by the purpose plus the follow-up instruction to store the key and set PAYWALL_API_KEY, which tells the agent what to do after calling. However, it names no alternatives or prerequisites (e.g. that this must precede authenticated paywall_* calls), leaving the when-to-use routing to inference.

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

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

With no annotations, the description carries the full burden and does disclose two genuinely actionable traits: an auth requirement (PAYWALL_API_KEY) and propagation latency (changes go live in ~20s). It stops short of saying what happens to fields that are omitted in a partial update, or whether the change is reversible.

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

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

A single front-loaded sentence: the tool family tag, the operation, examples of what changes, the live-propagation caveat, and the auth prerequisite. No filler or restatement of the name.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description covers purpose, auth, and propagation timing well. The remaining gap is PATCH semantics — whether omitted fields are left untouched or cleared — which an agent needs before performing a partial update.

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 every parameter (id, path, asset, payTo, price, method, network, description, upstreamUrl) is already documented in the schema. The description only names two of the updatable fields as examples and adds no format or syntax detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ("Partial update of a route") and gives concrete examples of what can change (price, payout wallet). It implicitly separates itself from paywall_create_route/paywall_delete_route/paywall_list_routes via the update semantics, but never names an alternative explicitly.

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

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

Usage is implied — modify an existing route identified by id — and the prerequisite (needs PAYWALL_API_KEY) is stated, which is useful. However there is no explicit when-to-use/when-not guidance or routing to a sibling tool for related operations.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the data routing layer and source venues (Coinbase, Alpaca SIP), which is genuinely useful context, but says nothing about authentication requirements, rate limits, quote freshness/delay, or behavior for unknown symbols.

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 body is duplicated verbatim ('Current spot price for crypto ... shared routing layer' appears twice), wasting roughly half the text. The remaining content is front-loaded and useful, but the repetition is a clear structural defect.

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

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

With no output schema and no annotations, the description should ideally indicate the return shape (price, timestamp, currency) and error behavior for invalid symbols. It is adequate for a two-parameter quote tool but leaves the agent guessing at the response format.

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 both parameters are already documented (class = stock|crypto, symbol examples). The description's example URL adds the call shape but does not explain the class parameter's role or the curated-list fallback beyond what the schema states, so the baseline 3 is correct.

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

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

States a specific verb+resource ('Current spot price for crypto ... or US equities/ETFs') and names the underlying venues (Coinbase, Alpaca SIP), which tells an agent this is a quote lookup rather than a candle/history call. It does not explicitly name the sibling it competes with (e.g. ohlcv, market_overview), so differentiation is inferential rather than stated.

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

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

No guidance on when to use this versus alternatives such as ohlcv, market_overview, or orderbook. The example URL implies a simple lookup use case, but there is no stated condition, prerequisite, or exclusion anywhere in the description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure and largely does not meet it. It conveys only that results are current ('latest'), saying nothing about pagination behavior, default/max result sizes, auth or rate limits, or what a 'verdict' value looks like.

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 single sentence is repeated verbatim after an em dash, so half the text is pure duplication with zero information gain. There is no other structure or front-loading to compensate.

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

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

For a filtered list tool with four optional parameters, no annotations, and no output schema, the description should at least characterize the returned rows and pagination strategy. It provides no return-value context and no guidance on how the filters interact, leaving the agent to guess at output shape.

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

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

Schema description coverage is 100%, with limit, offset, min_tvl, and category all documented in the schema itself, so the baseline is 3. The description adds no parameter-level meaning beyond the schema (it does not clarify pagination interaction or filtering semantics).

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

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

The description states the resource (all tracked protocols) and the payload (latest health score and verdict), so an agent can infer it is a bulk list of protocol health summaries. However, it never uses a verb and gives no differentiation from close siblings such as protocol_health_scoreboard or protocol_health_score, which presumably cover similar ground.

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

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

There is no when-to-use guidance, no mention of alternatives, and no exclusions. Usage is only weakly implied by the phrase 'all tracked protocols', which suggests a broad listing rather than a targeted lookup, but nothing routes the agent between this and protocol_health_score / protocol_health_scoreboard.

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

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

With no annotations provided, the description carries the full behavioral burden. It conveys only that the operation bypasses caching ('force', 'live', 'immediate'), but not whether it is expensive, rate-limited, long-running, async, or whether it mutates shared state across all tracked protocols.

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

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

The description is short but wastes its entire budget by repeating the same sentence twice verbatim ('Force an immediate live re-score of all tracked protocols'), with no front-loaded differentiation or additional detail.

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

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

For a zero-parameter tool this is minimally adequate: the core action is stated. Still missing is what the refresh affects, whether it runs synchronously, and how results are surfaced (no output schema exists), which matters for a bulk forced re-score.

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

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

The tool takes zero parameters and the schema is trivially complete, so there is nothing for the description to clarify. Baseline 4 applies for a parameterless tool.

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

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

The description states a clear verb and resource ('force an immediate live re-score of all tracked protocols'), so the basic action is understandable. However, it does not distinguish this tool from close siblings like protocol_health_score, protocol_health_scoreboard, or protocol_health_sync_universe, leaving the agent to guess which refresh/score path applies.

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

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

There is no guidance on when to invoke a forced refresh versus reading cached results via protocol_health_scoreboard, nor any precondition (e.g., rate limits, cost, or timing) for triggering a bulk live re-score. The word 'force' implies bypassing a cache but the description never says when that is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It does add real value by enumerating the returned components and score history in the absence of an output schema, but it omits whether the read requires auth, how fresh the score is, or what happens for an unknown slug.

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 text is duplicated verbatim (the sentence appears twice, separated only by a dash), which is pure waste and suggests a generation artifact. Aside from that redundancy the single sentence is reasonably front-loaded.

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

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

With no output schema and no annotations, the description is the only source of behavioral context; it partly compensates by listing the returned components, but it says nothing about error cases, freshness, or how it relates to the scoreboard/refresh siblings, leaving meaningful gaps for a two-parameter oracle tool.

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

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

Schema description coverage is 100% and both parameters are fully documented in the schema (slug as defillama_slug, history with default 10 / max 100). The description adds no parameter-level detail beyond that, so the baseline of 3 applies.

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

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

States a specific resource ('latest health score for one protocol') and enumerates what the score comprises (GitHub activity, TVL trend, treasury, source details, history). It does not, however, distinguish itself from close siblings like protocol_health_scoreboard or protocol_health_list_protocols, so an agent must infer which one returns a single protocol's score.

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

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

There is no explicit when-to-use guidance, no mention of alternatives, and no stated preconditions (e.g., that the protocol must first be tracked via protocol_health_track_protocol). The description only says what is returned, leaving selection between the four protocol_health_* siblings to guesswork.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the data provenance (DefiLlama, TVL > $1M, plus curated protocols) and precisely what fields are omitted (components/history), which is genuine behavioral context, but it says nothing about auth/paywall requirements, rate limits, or ordering.

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

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

The entire description is duplicated verbatim — the same sentence appears twice, wasting roughly half the text. The content is front-loaded and otherwise tight, but the copy-paste repetition is a concrete structural defect.

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

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

For a no-annotation, no-output-schema listing tool, the description does convey the returned shape (name, score, verdict) and the coverage universe. However, it omits filtering behavior, pagination semantics, and any indication of the paywall boundary implied by 'teaser', leaving gaps an agent must guess at.

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 all four parameters (limit, offset, min_tvl, category) are already documented in the schema. The description adds no syntax, default, or interaction detail beyond that, so the baseline 3 applies.

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

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

States a specific resource (protocol health scoreboard) and scope (full tracked universe, name/score/verdict only). It distinguishes itself from single-protocol siblings like protocol_health_score by saying it covers the whole universe, though it never names those siblings explicitly.

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

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

The phrase 'public teaser' and 'no components/history' hints that a richer tier exists, but the description never says when to use this versus protocol_health_score or protocol_health_list_protocols, nor when to avoid it. No explicit routing guidance.

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

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

With no annotations, the description must carry the full behavioral burden. It usefully discloses that this is a forced/on-demand mutation of a shared dataset with a built-in daily cadence and a $1M tracking threshold, but it says nothing about whether the call blocks, how long a sync takes, what happens on concurrent or repeated triggers, or what it returns.

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

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

The core statement is front-loaded and the cadence note earns its place, but the first sentence is duplicated verbatim, wasting roughly half the text and suggesting a generation artifact rather than deliberate emphasis.

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

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

For a zero-parameter trigger with no output schema and no annotations, the description covers what it does, its scope and its cadence. It omits the operationally relevant facts an agent would want before invoking a forced sync — blocking behavior, duration, deduplication — which matters more here than for a read-only sibling.

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

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

The schema takes zero parameters, so there are no parameter semantics to document and the baseline of 4 applies. The description does not misleadingly imply any inputs are available.

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

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

States a specific verb (sync), a specific resource (tracked-protocol universe), its source (DefiLlama) and its scope filter (TVL > $1M). It is clearly distinguishable from sibling readers like protocol_health_score, but it never contrasts itself with the closest sibling, protocol_health_refresh_all, leaving that distinction to inference.

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?

"Runs automatically once/day; use this to trigger it on demand" gives a concrete when-to-use condition and implies the tool is only needed outside the daily cadence. It stops short of naming an alternative (e.g. refresh_all) or stating any preconditions, so it is clear context but without explicit 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses only that scoring happens immediately from GitHub + DeFiLlama data; it says nothing about persistence, idempotency, auth requirements, or what happens if the protocol already exists. For a mutation tool this is a substantial gap.

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

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

The core sentence 'Track a new protocol' is duplicated back-to-back, and the '[Protocol Health Oracle]' prefix is marketing filler rather than information. Structure is not front-loaded with anything the agent needs.

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

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

For a mutation tool with no annotations and no output schema, the description should explain what the tool creates or persists and what the caller receives. It omits both, leaving the agent unable to predict the tool's effect beyond 'it scores immediately'.

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 all five parameters are already documented with examples in the schema. The description's mention of GitHub and DeFiLlama data loosely maps to the github_repo and defillama_slug params but adds no syntax or format detail beyond what the schema provides. Baseline 3 applies.

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

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

The description states a verb and resource ('Track a new protocol') but immediately repeats it verbatim after the '[Protocol Health Oracle]' tag, adding no information. It does not differentiate from siblings like protocol_health_score, protocol_health_list_protocols, or protocol_health_sync_universe, so an agent cannot tell them apart without opening schemas.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as protocol_health_score or protocol_health_refresh_all. The agent is left to infer the context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It names the data source (FRED) but says nothing about whether it is a read, rate limits, auth requirements, caching, or the shape of the response.

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

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

The core sentence is duplicated verbatim (repeated after a dash separator), which is pure waste and makes the description look malformed. The one useful piece, the example endpoint, is buried at the end.

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

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

With no output schema and no annotations, the description should carry more load. It conveys the data domain and source but omits return format, defaults when 'series' is omitted, and the safety/read profile, leaving real gaps for a data-fetch 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%, so the single 'series' parameter is already fully documented in the schema. The description adds only the data domain (1M–30Y curve, spread series) but no extra semantics about how 'series' interacts with it, so baseline 3 applies.

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

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

States a specific resource (US Treasury yield curve 1M–30Y plus recession-indicator spreads 10y-2y/10y-3m) and its source (FRED). An agent can tell what data this returns, though it offers no explicit differentiation from sibling data tools like macro_calendar or market_overview.

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

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

There is no when-to-use guidance, no mention of alternatives among the many sibling tools, and no exclusions or prerequisites. The agent is left to infer that this is the yield-curve lookup versus e.g. macro_calendar.

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

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

With no annotations, the description carries the full burden. It usefully discloses access characteristics ('Public and free' – no auth or payment required), but says nothing about how many results are returned, how 'top scored' is computed, ordering, or refresh/caching behavior.

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

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

Two short fragments, fully front-loaded, with zero filler. Every word carries information.

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

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

For a parameterless listing tool with no output schema, the description should at least characterize the return set (size, ordering). It conveys scope and access but leaves the result shape entirely unspecified.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the fact that no filtering input is accepted, which is implicit.

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

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

States a specific resource and scope: top-scored active tools from the Wicked Registry. An agent can identify it as a ranked-listing tool, though it doesn't explicitly contrast itself with sibling registry_search_tools or registry_tool_detail.

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

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

There is no indication of when to call this versus the other registry_* siblings (search, detail, badge, report). No prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the full behavioral burden and does so well on the critical path: it discloses that a signature is required, gives the exact signed message template, and explicitly states the tool never signs for you. It omits secondary traits such as idempotency/re-registration behavior, failure modes, or 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?

Two sentences, front-loaded with purpose before the auth requirement, with no filler. The embedded message template is verbose but is required payload information rather than padding.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description covers the purpose and the signing prerequisite adequately but leaves several parameters and any sense of the return/registration result unexplained. It is sufficient to attempt the call but not fully self-contained.

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

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

Schema coverage is 67%, so the schema documents most parameters; the description adds genuine meaning by showing how name, endpoint_url, and timestamp feed into the signed message and tying signature/owner_wallet together. It says nothing about category, description, protocol, or schema_url, leaving part of the parameter set unclarified.

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

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

States a specific verb and resource (register a tool) plus the outcome (real synthetic checks and a live score), scoping it to tools 'you own'. It does not explicitly differentiate itself from sibling register-style tools like identity_register or broker_sync_register_user, but the outcome wording makes the purpose unambiguous.

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

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

The description implies when to use it (when you want your own tool scored), but never states when not to use it or names alternatives such as registry_search_tools or registry_tool_detail. Usage must be inferred from the stated benefit rather than from explicit routing guidance.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that the submission is public, rate-limited, manually reviewed, and never auto-suspends a tool, but it omits auth requirements and what the submission creates or returns.

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