Wicked MCP

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?

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about auth, rate limits, delivery latency, or pagination beyond what the schema already encodes. It does disclose output shape ('each event lists every item with its official label'), which is modestly useful given there is no output schema, but the safety and freshness profile is undocumented.

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 repeated verbatim a second time, wasting roughly half the description on duplication. The category list is front-loaded well, but the copy-paste block violates any reasonable conciseness bar.

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 6-parameter tool with no output schema, the description does cover the category vocabulary and gives a concrete query example, which is the essential missing piece. However, it omits any indication of how results relate to the other filings tools and provides no return-structure detail beyond a single clause.

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 nominally 100%, but the category parameter has no enum in the schema and instead says 'One of the category names above' — the description supplies the actual 15 allowed values, without which the schema reference would be unresolvable. That is genuine added meaning beyond the structured fields.

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 (8-K material-event alerts) and enumerates the 15 actionable categories, so an agent can tell it retrieves classified 8-K events rather than raw filings. It does not, however, contrast itself with siblings like filings_search or filings_latest_preview, so sibling differentiation is absent.

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 when-not-to-use, and no named alternative among the filings_* siblings. The example URL hints at a bankruptcy-based query but does not tell the agent when this tool is preferable to filings_search or filings_filing.

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 payload shape (parsed items versus insider transactions, plus the document link), which is real behavioral value, but it says nothing about auth requirements, rate limits, or not-found/error behavior for an ID lookup.

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?

Sized appropriately overall and front-loaded with the scope, but the main sentence is duplicated verbatim, which is pure waste and makes the opening read as repetition rather than 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 one-parameter, read-only lookup with no output schema, the description covers the resource, the identifier, the returned content, and a concrete example. Only error/not-found behavior and any sibling routing guidance are 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 accession parameter is already fully documented, including the same example format. The description's example URL merely restates that format, adding no new meaning beyond the schema.

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

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

States a specific verb+resource: it fetches exactly one filing identified by an SEC accession number, and it names what comes back (parsed items or insider transactions plus the SEC document link). That distinguishes it from filings_search (query-based) and the insider_* siblings, 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?

Usage is implied by the single required parameter: call it when you already hold an accession number. There is no explicit statement of when to prefer this over filings_search or filings_latest_preview, and no mention of what happens when the accession 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 and no output schema, the description carries the full behavioral burden. It discloses useful traits: the 200-filing measurement window, that lag is measured from SEC acceptance time, and that the endpoint is free (no paid tier/auth gating). It never states read-only semantics, rate limits, or refresh cadence, so the safety profile is left to inference.

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 body is duplicated verbatim, doubling the length with zero added information — a clear structural defect. The lead '[Filings Oracle]' tag and the metric list are front-loaded well, but half the text is pure waste.

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 enumerate return values, and it does so thoroughly: poll recency, newest filing age, median and p95 lag, per-form-type poll status, and row counts. For a zero-parameter metrics endpoint that is nearly sufficient, with only read-only semantics and latency expectations left unstated.

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

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

The tool takes zero parameters, so the baseline is 4. Nothing in the schema needs compensation, and the description correctly describes a no-argument reporting endpoint rather than implying hidden filters.

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

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

The description names the exact resource and the specific measurements returned: seconds since last successful SEC poll, newest filing age, median/p95 ingest lag over the last 200 live filings, per-form-type last poll, and stored row count. A specific verb is absent (it reports rather than 'gets'), and it never names a sibling, but the freshness/diagnostics intent is unambiguous against the content-oriented filings_* siblings.

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

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

'Proof of real-time' and the '- Free' tag imply the use case — auditing whether the SEC data pipeline is current before trusting other filings_* results — but no explicit when-to-use, exclusions, or alternatives are stated. Usage is inferable rather than prescribed.

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 helpfully discloses what the tool returns and pins down the cluster-buying threshold ('three or more insiders buying'), but says nothing about auth requirements, data recency, rate limits, or whether the window is calendar vs. trading days beyond the schema's default/max.

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 opening sentence is duplicated verbatim, wasting half the description with zero added information. The example URL is a genuine asset, but the duplication badly damages front-loading and density.

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 tool with 100% schema coverage and no output schema, the description compensates well by enumerating the returned aggregate fields. Only auth/data-source context is absent, which is a minor gap given the schema already documents both inputs.

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 ticker/window scoping ('one ticker over a window') and the example shows both parameters in use, but adds no format or constraint detail beyond the schema (ticker format, behavior at the 90-day cap).

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 and operation ('Insider activity rollup for one ticker over a window') and enumerates the returned aggregates (buy/sell counts, dollar totals, net flow, distinct buyers/sellers, cluster-buying flag, largest trades). This clearly differentiates it from the raw-list sibling filings_insider_trades, though the description never names that 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?

Usage is only implied: 'rollup for one ticker over a window' suggests a summarization use case, and the example URL shows invocation. There is no explicit when-to-use vs. when-to-use-a-different-tool guidance, and no mention of the closely related filings_insider_trades alternative.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the default filtering behavior (P and S only unless all_codes=true) and the 10b5-1 dimension, which are real behavioral traits. It says nothing about auth requirements, rate limits, pagination via the since cursor, or the long-poll behavior of wait, leaving meaningful behavioral 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 entire opening sentence is duplicated verbatim, wasting roughly half the description with zero added information. The useful parts (default scope, example) are present but buried after the redundant copy, hurting 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?

For an 11-parameter, all-optional query tool with no annotations and no output schema, the description does compensate somewhat by enumerating the returned fields. However it omits any routing guidance versus the insider_summary sibling and leaves cursor/pagination semantics to the schema, making it only minimally 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%, so the schema already documents all 11 parameters, including defaults and maxes (days max 90, limit max 200, wait max 25). The description adds no parameter-level meaning beyond restating returned fields, and the example URL only illustrates a couple of params. Baseline 3 is appropriate 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 and resource ('Form 4 insider transactions parsed to one row per trade') and enumerates the exact columns returned (insider, role, security, code, shares, price, value, shares owned, direct/indirect, 10b5-1). An agent immediately knows what this tool produces. It does not, however, differentiate itself from the sibling filings_insider_summary, which likely covers 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?

The description notes the default scope ('Defaults to open-market buys and sells only'), which implies when you'd reach for all_codes or side. But it never names an alternative tool or states when to prefer filings_insider_summary or filings_search over this one, so usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose meaningful trait information: results are capped at 10, only four fields are present, and no filtering or cursors are supported. It does not state whether auth is required for the free tier or what the response envelope 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 core sentence is stated verbatim twice in a row, wasting roughly half the text. The example path is useful, but the duplication 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?

No output schema exists, yet the description enumerates the returned fields and the 10-row cap, which is the key information an agent needs. Coverage is adequate for a no-parameter preview endpoint, though auth and rate-limit behavior under the free tier remain unstated.

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

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

The schema has zero parameters and 100% coverage, so the baseline of 4 applies. The description correctly implies a no-argument call by listing fixed returned fields rather than any 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?

Names a specific resource and scope: the 10 most recent filings across all form types, and enumerates the four fields returned. It does not differentiate itself from the many sibling filings_* tools (filings_search, filings_freshness, filings_filing), so the agent must infer routing from the endpoint path alone.

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

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

Implies usage through 'Free' and 'Preview' plus a pointer that full structured data, filtering and cursors require /v1/filings, which tells the agent when this is insufficient. However, it names an HTTP path rather than an actual sibling tool, so the routing guidance is only implied rather than actionable.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses ingestion latency (~1 minute after SEC acceptance), that wait= blocks the request until a filing lands, and that cursor results come back oldest-first. It omits auth/credential requirements and rate limits, but the latency and long-poll semantics are exactly the kind of trait annotations would otherwise supply.

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

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

Front-loaded with the core purpose and example, but the first sentence is duplicated verbatim ('Structured SEC filings feed ... — Structured SEC filings feed ...'), which is pure waste in an otherwise short description. The remaining sentences are reasonably efficient.

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

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

For an 8-parameter, no-required, no-output-schema feed tool, the description covers what the resource is, how to filter it, both retrieval modes (cursor paging and long-poll), and freshness latency. Missing pieces such as auth expectations and response envelope details are minor given the schema fully documents the inputs.

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 (cik, days, form, item, wait, limit, since, ticker) is already documented in the schema. The description only restates the filter fields and paging/cursor concepts at a high level, adding no syntax, format, or edge-case meaning beyond the schema.

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

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

States a specific resource and scope: a structured SEC filings feed covering named form types (8-K, Form 4, Schedule 13D/13G, 10-K, 10-Q), with filtering and paging modes. An agent can tell this is the general filings feed, but the description never distinguishes it from siblings like filings_8k_events, filings_freshness, or filings_latest_preview, which overlap heavily with its stated scope.

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

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

It describes operational modes ('page with a cursor, or long-poll with wait=') which implies when to use each, and gives a concrete example query. But there is no explicit when-to-use guidance against alternatives and no exclusions, so the agent must infer the routing from sibling names alone.

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

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

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 delivers strong behavioral detail: a 30s budget, the clock starting on return, a one-pass answer constraint, and a required fresh nonce. It omits failure/timeout semantics and what the challenge payload contains, keeping it just short of full transparency.

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

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

Three dense sentences with the core action and deadline constraint front-loaded, followed by the real-wallet and sandbox invocation notes. Every sentence earns its place, though the parenthetical density slightly strains readability.

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 challenge-issuing tool with no output schema and no annotations, the description supplies the timing contract, the required workflow, and the auth-mode branching. It is nearly complete, only missing detail on the returned challenge structure and timeout/failure behavior.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds ordering meaning beyond the schema by specifying the nonce must be signed for the NEXT call and that sandbox uses wallet + sandbox_token instead of nonce/signature. This contextualizes the mutually-exclusive parameter sets rather than merely restating field docs.

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: 'Request a real time-boxed liveness challenge (constrained-generation task, 30s budget)'. It clearly delineates this from identity_get_nonce (prerequisite) and identity_submit_response (follow-up), so an agent can position it in the workflow 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?

Explicitly states the follow-up path ('answer in ONE pass via identity_submit_response before expires_at') and names the prerequisite ('fetch + sign the nonce for the NEXT call before calling this'). It also routes between the real-wallet and sandbox invocation modes, giving when-to-use context and 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 single-use behavior, a 5-minute TTL, and the real-wallet vs sandbox distinction. It stops short of describing response shape, error behavior, or any auth/permission requirements beyond the nonce flow.

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 front-load the action and then add the critical constraints (single-use, TTL, sandbox exception). Every phrase earns its place.

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

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

For a simple one-parameter tool with no annotations or output schema, the description is nearly complete: it explains the nonce/message purpose, TTL, single-use nature, and sandbox exclusion. It could still specify the response format more explicitly, but an agent has enough 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 wallet parameter is already documented. The description adds useful context by framing the tool as the real-wallet path and saying it is not needed for sandbox identities, but it does not add syntax or validation 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 action ('a one-time nonce + message to sign') and places it in context ('Real-wallet path, step 1'). It also distinguishes the tool from sandbox identity flows with 'Not needed for sandbox identities.' An agent can identify both the purpose and the relevant boundary versus sibling identity tools.

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

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

It clearly says when the nonce is required ('Every signed identity call needs a fresh nonce') and when it is not ('Not needed for sandbox identities'). However, it does not name the alternative tool or flow for sandbox identities, so an explicit alternative is missing.

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

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

With no annotations to lean on, the description carries the full burden and does well: it discloses key expiry (7 days), the rate limit (20 requests/min), and an abuse limit (5 per IP per day). It omits whether authentication is required and does not describe the returned key material, but the operational constraints an agent needs 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?

A single dense sentence, front-loaded with the verb and resource, followed by constraints. Every clause earns its place and there is no filler.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description covers the key behavioral facts an agent needs (expiry, rate limit, daily cap, intended consumer). It could note the returned value since there is no output schema, keeping it just short of 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% and the single optional 'label' parameter is fully documented there. The description adds no meaning about the parameter, so the baseline of 3 for a fully-covered schema is appropriate.

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

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

The description states a specific verb+resource: 'Get a free self-serve test API key,' with clear qualifiers (7-day expiry, 20 req/min). It is distinguishable from identity_status and other identity_* siblings, though it does not explicitly differentiate itself from registry_create_api_key, which also mints keys.

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 names the intended use — as the api_key for identity_status — and offers the alternative it replaces: 'instead of paying via x402.' That is a clear use-context with an alternative, but it stops short of stating when NOT to use it (e.g., for production keys vs registry_create_api_key).

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 disclose meaningful traits: cost ('Free'), key algorithm (RS256), that keys are public, and that sandbox uses a separate key set. It omits caching/rotation and rate-limit behavior, which matter for a JWKS endpoint, so it is not complete.

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

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

Two tightly packed sentences, front-loaded with what the endpoint returns and followed by the sandbox caveat. No filler or redundant restatement.

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, no-output-schema key-fetch tool, the description covers purpose, cost, and the sandbox variant, which is sufficient to call it correctly. Naming it a JWKS implicitly conveys the return shape, though the exact response format is not spelled out.

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 param is already documented with its issuer value in the schema. The description restates the sandbox behavior and adds only that sandbox keys sign sandbox assertions, so it clears the baseline without adding much 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 (public RS256 keys) and its use (verify an assertion_token locally), which is concrete and actionable. It does not differentiate itself from the nearby sibling identity_get_test_key, so it stops 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?

Gives implied context ('to verify an assertion_token locally') and a routing hint for the sandbox variant, plus a cost note ('Free'). It never states when to prefer this over identity_get_test_key or identity_status, leaving sibling selection to inference.

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

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

With no annotations, the description carries full burden. It usefully discloses that it never signs, that a signature is required, and that registration requires no stake, which is real behavioral context. However it omits what happens on success, whether the wallet becomes permanently bound, idempotency, and any auth/error behavior — notable gaps for a mutation 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 compact sentences, with the scope constraint front-loaded and the sibling routing last. Every sentence earns its place; no filler.

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

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

Covers the prerequisite chain and sibling differentiation well for a 3-required-param mutation with no annotations and no output schema. It stops short of describing the post-registration state or return, which is the main remaining gap.

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

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

Schema coverage is 100%, so each of wallet, nonce, and signature is already documented. The description reinforces nonce freshness and signature-over-message semantics but adds no syntax or format 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 (register) and resource (REAL wallet/identity), and explicitly names the sibling it is not — sandbox identities go to identity_sandbox_register. An agent can distinguish it from identity_get_nonce and identity_sandbox_register without opening any schema.

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

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

Explicitly gives the prerequisite flow (sign over identity_get_nonce's message), a key constraint (no stake required), and the alternative route for sandbox identities. Nothing about when to pick this tool is left to inference.

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

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

No annotations exist, so the description carries the full burden, and it does most of it well: no signing, no body, results signed with a separate sandbox key (identity_jwks sandbox=true), never reported as verified, and a concrete rate limit of 10 per IP per hour. It leaves minor gaps such as whether repeated calls mint multiple wallets or are idempotent, which keeps 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?

Front-loaded with the decisive routing cue ('START HERE'), then the return values, then the follow-up chain, then caveats and the rate limit. Every clause carries information an agent needs; nothing is padding despite the density.

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, no output schema, and zero parameters, the description must supply routing, return semantics, downstream usage, trust level of results, and quota — and it covers all of these. An agent has everything required to call it and correctly interpret what comes 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?

The tool takes zero parameters, so the baseline of 4 applies per the rubric. The description explains the call's output/return artifacts (sandbox wallet + sandbox_token) and how they feed downstream calls, which is the relevant semantic content for a no-arg 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?

States a specific verb+resource (registers/creates a sandbox wallet and token) and immediately distinguishes itself from siblings with 'START HERE if you have no wallet or cannot sign messages,' implicitly separating it from identity_register which requires a real wallet. An agent can pick this over identity_register/identity_get_test_key without opening a schema.

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

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

Gives an explicit condition for use ('no wallet or cannot sign messages'), names the follow-up chain (identity_get_challenge then identity_submit_response with wallet + sandbox_token), and names the alternative ('Use a real wallet for an accountable identity'). When-to-use, what-to-do-next, and when-not-to-rely-on-it are all present.

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 meaningful behavior: the no-signature read model, the x402/api-key auth options, and the important sandbox caveat that sandbox wallets are never `verified` and instead report sandbox:true and sandbox_verified. It lacks details on rate limits or failure modes, but the auth and sandbox semantics are genuinely useful.

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 core question and only then moving to payment/auth and the sandbox edge case. No filler, though the second sentence is information-dense enough to slow parsing slightly.

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

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

For a two-parameter, no-output-schema query tool, the description covers the essential semantics: what is being checked, how to authenticate/pay, and how sandbox results differ. The only gap is the exact shape of a successful non-sandbox response, which is implied by the `verified` and `sandbox_verified` fields.

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, and the description goes beyond the schema by explaining api_key provenance (identity_get_test_key) and the IDENTITY_API_KEY environment-variable alternative, which the schema's 'Optional x-api-key' note does not mention.

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 question the tool answers — whether a wallet holds a valid, unexpired assertion — with a clear resource (wallet identity/assertion). An agent can distinguish it from sibling read tools like reputation_status or identity_jwks, though the description never explicitly contrasts with them.

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

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

Explicitly describes the access paths: no signature required, pay via x402, or pass api_key obtained from the named sibling identity_get_test_key / IDENTITY_API_KEY env var. It does not say when to prefer this over reputation_status or reputation_query, so it stops short of full alternative routing.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses scoring outcomes, that the assertion_token is short-lived and JWT-signed, and a critical replay-protection constraint (fresh nonce, not the challenge nonce). It doesn't cover failure modes or rate limits, keeping it off 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 dense clauses with no filler; the outcome/scoring and the returned token are front-loaded, then the two auth paths are contrasted compactly. Slightly dense but every sentence earns its place.

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

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

For a 6-param mutation-style tool with no annotations and no output schema, the description covers the key agent needs: how to authenticate in each mode and what a pass yields. Missing only error/retry behavior and sandbox pass semantics, minor 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 six parameters are already documented in the schema, including the real-vs-sandbox split. The description largely restates that split rather than adding syntax, format, or edge-case meaning beyond it, 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 (submit response) and resource (a challenge answer) plus the outcome semantics (scored pass/fail/inconclusive) and the artifact produced (short-lived signed assertion_token JWT). This clearly distinguishes it from identity_get_challenge, identity_get_nonce, and identity_jwks among the identity siblings.

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

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

Gives concrete routing: real wallet requires a DIFFERENT fresh nonce than identity_get_challenge used, sandbox requires wallet + sandbox_token, and the token is verifiable via identity_jwks. It doesn't state explicit when-not-to-use conditions, but the two auth paths are clearly laid out.

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

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

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.