Echo Sentiment — XLM Market Sentiment

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

With no annotations present, the description carries the full burden of disclosure. It transparently states that the tool is paid, costs $1.00, returns a bundle_token, and demands a payment requirement until certain credentials are supplied. It does not cover edge cases such as idempotency or failed payments, but the core side effects are clearly disclosed.

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

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

The description is dense, front-loaded with the price, and every sentence contributes information. It is somewhat run-on and could be broken into clearer bullets, but it is compact and contains no filler.

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

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

For a simple token-purchase tool with no output schema, the description covers the two possible return outcomes (bundle_token or payment requirement) and the credentials needed to avoid the payment requirement. The header-versus-parameter ambiguity and lack of explicit enterprise alternative leave a small gap, but the essential calling context is present.

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

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

Schema description coverage is 0%, so the description must add parameter meaning, and it largely does: bundle_token is described as a token to pass to other tools, api_key as a free-tier key obtainable from get_free_api_key, and payment as the required payment mechanism. The phrase 'payment header' is slightly inconsistent with the schema's `payment` parameter, which prevents a perfect score.

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

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

The description clearly states the tool's function: it sells a prepaid credit bundle where $1.00 buys 10 standard call credits or 5 premium reports and returns a bundle_token. This is a specific resource and outcome, but it does not explicitly differentiate itself from buy_enterprise_bundle beyond the price and token usage.

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

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

It gives useful invocation context by explaining that a payment requirement is returned until the tool is called with a payment value, a prepaid bundle_token, or a free-tier api_key, and it even points to get_free_api_key. However, it does not explicitly state when to choose this tool over buy_enterprise_bundle or when not to use it, leaving alternative selection 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 provided, the description carries the full burden of behavioral disclosure. It transparently discloses the $25 per-call cost, that it returns a bundle token, and that it returns a payment requirement unless called with a payment header, prepaid bundle_token, or free-tier api_key. This gives agents a clear picture of the tool's behavior, though it does not mention reversibility or edge cases.

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

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

The description is three sentences long, front-loaded with cost and purpose. It includes a URL (endpoint) which is somewhat extraneous but not harmful. It is efficient and well-structured, with key information presented early.

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

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

Given the tool's complexity (3 optional parameters, no output schema, no annotations), the description covers the essential behavior: purchase, return token, payment requirement conditions, and alternative for free tier. It does not describe the exact output format of the payment requirement or error handling, but it provides enough for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must explain parameter meanings. It does: api_key is a free-tier key (minted via get_free_api_key), payment is a payment header, and bundle_token is a prepaid token. This adds meaning beyond the raw schema, though it does not specify formats or types in detail.

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

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

The description clearly states the tool's purpose: it purchases an enterprise prepaid bundle for high-volume agents and returns a bundle token for use with other tools. It distinguishes itself from siblings like buy_call_credits_bundle by specifying 'enterprise' and 'high-volume', and it mentions get_free_api_key as an alternative for free-tier access.

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

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

The description provides context for when to use the tool ('for high-volume agents') and mentions an alternative (get_free_api_key for free tier). It also explains the conditions under which a payment requirement is returned, but it does not explicitly state when not to use this tool versus other purchase options. Clear context but no explicit 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 it does surprisingly well: it discloses the $0.02 cost, that calls return a payment requirement until supplied with a payment header, bundle_token, or api_key, and that the output is a heuristic. It still omits error behavior for bad addresses and any rate limits or failure modes.

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?

Dense but well front-loaded: the paid cost and purpose lead, followed by outputs, chains, params, and the payment/auth mechanics. Each sentence carries information with little 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 usefully describes the return payload (score, verdict, flags), and it explains the payment gating and supported chains. Complete enough to call correctly, with only minor gaps around input validation and rate limits.

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

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

Schema coverage is 0% and the schema gives bare titles, but the description compensates by explaining chain examples (base), the address format (0x… or a Solana mint), and the role of payment, bundle_token, and api_key. All five parameters are addressed, though the exact accepted chain strings and key-format expectations remain unstated.

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 ('Rug-check verdict for an on-chain token') and enumerates the concrete outputs (0-100 risk score, verdict, flags for honeypot, mint/freeze authority, taxes, holder concentration, LP lock). This clearly distinguishes it from data-oriented siblings like get_base_wallet_intel or get_whale_flow.

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 'rug-check' framing and the supported chain list, and it helpfully points to get_free_api_key for minting a free-tier key. However, it never states when to prefer this over other safety-adjacent siblings or any exclusions/limits on the heuristic's reliability beyond 'not financial advice'.

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

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

With no annotations provided, the description carries the full burden. It discloses the $0.10 per-call cost, the payment-requirement behavior until authenticated, and the live nature of the data. It does not cover rate limits or failure modes, but the key behavioral trait—paid access—is clearly exposed.

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 cover price, endpoint, function, output nature, and auth methods without padding. Every sentence contributes information. The title redundantly repeats the price, but the description itself is efficiently front-loaded with the cost.

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 three simple parameters and no output schema, the description provides enough for an agent to invoke it correctly: what it does, what it costs, and how to authorize. It could add expected response shape or failure semantics, but nothing essential is missing for a first call.

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

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

Schema coverage is 0%, so the description must compensate, and it does: each of the three parameters (payment, bundle_token, api_key) is explained as an alternative authentication/payment method. It also directs users to get_free_api_key for obtaining a free-tier key. The only weakness is ambiguity about whether `payment` is a header or a schema parameter.

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

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

The description identifies a specific resource ('Live CEX<->SDEX arbitrage scanner') and a clear function: computing net spread after fees and producing a go/no-go verdict. This distinguishes it from sibling market-data tools like get_fear_greed_index or get_market_breadth, though it stops short of naming exactly which sibling it competes 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 context is implied: use this when you need live arbitrage opportunities. The description gives meaningful guidance on how to pay/authenticate, including a pointer to the sibling get_free_api_key, but it never explicitly states when to prefer this tool over alternatives or when not to use it.

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

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

With no annotations, the description carries full behavioral disclosure. It clearly states the $0.10 per-call cost, the payment requirement (header, bundle_token, or api_key), and that it returns a payment requirement until properly authenticated. It also discloses the signed nature of the quote, which is a key behavioral trait.

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

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

The description is informative and front-loaded with the price and core purpose, then covers payment options. It's slightly verbose but every sentence adds value; no filler. The length is justified given the need to explain the payment model.

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

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

Given no output schema and no annotations, the description covers the essential return content (signed price with signature and timestamp), the payment requirement, and the purpose. It lacks explicit error handling or example usage, but for a 4-parameter tool this is fairly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the roles of api_key, payment, and bundle_token, and implies ticker as the asset identifier. It adds meaning beyond the bare schema by clarifying authentication and payment mechanics, though it does not specify ticker formats.

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

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

The description clearly states the tool returns an 'Oracle-grade signed XLM price quote' with 'verifiable signature and timestamp', specifying the exact verb and resource. It distinguishes itself from sibling tools like get_xlm_quote by emphasizing the attested/signed nature, making its purpose unambiguous.

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

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

It provides context (suitable for contracts and settlement) and mentions the free-tier alternative (get_free_api_key) for payment, but does not explicitly contrast with the free get_xlm_quote or state when to prefer this over a non-signed quote. The guidance 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?

With no annotations, the description must carry the full behavioral burden. It discloses payment requirements ('PAID $0.02 per call'), explains that a payment requirement is returned until a payment method is provided ('payment header, bundle_token, or api_key'), and mentions the API endpoint. This provides transparency about the tool's behavior without annotations.

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

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

The description is concise (two sentences) and front-loaded with the price and URL, followed by the functional purpose and payment behavior. Every clause contributes useful information without redundancy.

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

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

For a tool with no output schema and only three simple parameters, the description covers the essential context: what data is returned (gas price in gwei, verdict), the payment model, and the specific use case. It does not detail the exact response structure, but given the simplicity, this is sufficient.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It explicitly mentions all three parameters—`payment`, `bundle_token`, and `api_key`—and clarifies their role as authentication/payment mechanisms that bypass the payment requirement. This adds meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Base (EVM) gas oracle: current gas price in gwei plus a submit-now / wait verdict for agents deciding when to broadcast a transaction.' This provides a specific resource (Base EVM gas) and the output (gas price + verdict), distinguishing it from all sibling tools, none of which are gas oracles.

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

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

The intended use case is explicit: 'for agents deciding when to broadcast a transaction.' It also references get_free_api_key as a way to obtain a free-tier key, which guides the user on how to access the tool. However, it does not explicitly contrast with alternative tools, though no direct alternative exists among 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?

With no annotations, the description carries the full burden and does disclose the paywall behavior: it returns a payment requirement until a payment, bundle_token, or free-tier api_key is supplied. However, the cost in the description ($0.02) conflicts with the title ($0.10), and 'payment header' does not perfectly match the schema's `payment` parameter.

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

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

The description is compact and front-loads the cost and endpoint before the functional details. The parenthetical about minting a free key is useful. The price duplication with the title adds slight noise but does not seriously hurt clarity.

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

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

For a tool with no output schema and no annotations, the description covers endpoint, cost, usage context, authentication options, and the main return fields. It does not explain address format, error responses, or the exact success response shape, but the core calling contract is clear enough to invoke the tool.

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

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

Schema coverage is 0%, so the description must compensate. It does by explaining that `address` is the target address and that `payment`, `bundle_token`, and `api_key` are alternative credentials for unlocking the call. It does not define formats, but it gives meaningful roles to all four parameters.

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

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

The description names the specific resource (Base/EVM wallet), the concrete outputs (ENS name, activity summary, USDC balance), and the use case (counterparty screening). This clearly distinguishes it from sibling tools like get_xlm_sentiment or get_base_gas_oracle.

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

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

It explicitly states when to use the tool: 'Useful for counterparty screening before a payment.' It also points to get_free_api_key as the way to obtain a free-tier key. It does not list exclusions, but no sibling tool overlaps with wallet intelligence.

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 thoughtfully discloses the cost and identifies the auth precondition: calls return a payment requirement until one of `payment`, `bundle_token`, or free-tier `api_key` is supplied. This is meaningful behavior beyond the schema. It does not detail failure modes beyond the payment gate, but the tool's read-only nature limits severity.

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

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

Four short sentences front-load cost and endpoint, then cover result shape, use case, and auth requirements. There is no redundant filler; every clause contributes.

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-value market tick with no annotations and no output schema, the description is remarkably complete: it specifies cost, endpoint, result fields, use-case fit, and the full set of authentication paths. An agent can determine how to invoke it and what to expect.

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

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

Schema coverage is 0%, yet the description adds semantics for all three parameters: `payment` is a paid header, `bundle_token` is prepaid, and `api_key` can be minted via get_free_api_key. It stops short of specifying exact value formats or how the parameters map to MCP arguments, so it does not fully compensate, but it is much more than the bare 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 explicitly identifies the resource (Crypto Fear & Greed index), the returned payload (0-100 value plus label and -1..1 sentiment score), and frames it as a cheap one-number tick. It is clear about the core function, though it relies on the tool name for the verb and does not name sibling tools to distinguish 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?

"Ideal for a poll loop" gives a concrete use case, and the payment/auth guidance states how to call it successfully. It does not explicitly list exclusions or sibling alternatives, but in context the target scenario is clear.

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

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

No annotations are provided, so the description carries the full burden — and it delivers: it discloses the free-tier scope, daily quota limitation, that no account is required, that the optional email is recorded (a privacy-relevant behavior), and an alternative HTTP transport. Only minor gaps remain, such as behavior when the daily quota is exhausted or whether keys expire.

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, zero fluff, and optimally front-loaded: the FREE tag and core return value lead, followed by usage instructions, then the email note, then the HTTP alternative. Every sentence earns its place and no information is repeated from the schema.

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

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

For a one-optional-param tool with an output schema present, the description covers the essential flow: what the key covers, how to consume it, the quota limit, and the recording of email. Minor omissions — quota-exhaustion behavior, key lifetime, error cases — are acceptable given the simplicity, though the HTTP endpoint detail is a nice bonus.

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

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

Schema description coverage is 0%, so the description must compensate for the sole `email` parameter. It does meaningfully: 'Optional `email` argument is recorded' tells the agent the parameter is not required and flags the side effect of being stored. It doesn't specify email format or validation, but for a defaulted string parameter this is adequate compensation.

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

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

The description states a specific verb and resource ('Returns a free-tier API key (X-Api-Key)') with concrete scope ('standard endpoints for a daily quota — no payment, no account'). It clearly differentiates from the buy_* siblings by contrasting free access with paid bundles, so an agent can distinguish this tool without opening either schema.

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

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

The description gives explicit usage context: pass the returned key as the `api_key` argument to any paid tool, and notes it works over plain HTTP. 'No payment, no account' plus 'daily quota' implies when to choose this over the paid bundle siblings, though the alternatives are never named explicitly and no when-not-to-use exclusions are stated.

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

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

With no annotations, the description carries the behavioral burden. It discloses the cost, the endpoint URL, and the important behavior that unauthorized calls return a payment requirement rather than data. It does not cover rate limits or exact response structure, but the core invocation behavior is 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?

Two sentences with no filler. The price and endpoint are front-loaded, followed by the functional purpose and the payment/authorization behavior. Every clause contributes necessary information.

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

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

The definition is solid for a paid read-only API, but gaps remain: no exact response fields, no error/payment-requirement response shape, and no guidance on how the `payment` header maps to the `payment` schema property. Given no annotations and no output schema, a bit more detail would be needed for fully reliable invocation.

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

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

Schema coverage is 0%, so the description must explain the three parameters. It maps api_key, payment, and bundle_token to distinct authorization paths ('free-tier api_key', 'payment header', 'prepaid bundle_token') and says how to obtain an api_key. It could clarify formats or whether 'payment header' means the `payment` parameter, but it adds meaningful semantics beyond the bare schema.

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

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

Description states a specific resource ('market breadth') and concrete output components: top-50 breadth, BTC dominance, XLM relative strength, and a single risk-on/risk-off verdict. This clearly distinguishes it from siblings like get_fear_greed_index or get_prediction_market_pulse.

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

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

Provides clear context: it is a market regime check and it is paid ($0.10/call). It tells the agent that calls require a payment header, bundle_token, or free-tier api_key炴and directs to get_free_api_key for minting one. It does not enumerate functional alternatives, but the context is clear.

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

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

The description discloses the paid nature, the endpoint, and the payment-until-authenticated behavior, which is especially valuable since no annotations exist. However, the title says $0.10 while the description says $0.02 per call, creating cost ambiguity, and it omits rate limits, error behavior, and post-payment response details.

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

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

The description is three sentences with cost and endpoint information front-loaded, followed by purpose and authentication mechanics. It is concise and mostly free of fluff, though the price mismatch and slightly compressed payment explanation prevent a top score.

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 paid tool with no annotations, no output schema, and four parameters, the description should explain the response format, limit semantics, and payment edge cases. It covers the payment requirement well but leaves these gaps, so an agent may not fully understand the resulting data or how to control it.

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

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

With 0% schema coverage, the description compensates by explaining api_key, payment, and bundle_token, including how they relate to headers and free-tier usage. However, the limit parameter is completely unexplained, leaving its default, format, and meaning unclear.

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

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

The description clearly identifies the resource (Polymarket pulse), the data returned (top prediction markets by 24h volume with implied odds), and the intended use (event probability signal for forecasting agents). This distinguishes it from sibling sentiment and market-breadth tools even without an explicit verb.

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 a forecasting use case and points to get_free_api_key for credentials, but it never explicitly states when to prefer this tool over alternatives like get_fear_greed_index or get_market_breadth. No exclusions or alternative-selection conditions are provided.

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 thoroughly: it discloses the exact price, the URL, the three authentication paths, and — critically — that an unauthenticated call returns a payment requirement rather than data. It also states keyless multi-chain operation and names the eight supported chains. This is unusually complete behavioral disclosure for a paid 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?

Front-loaded with price and purpose, then metrics, then auth — a sensible information order. The chain list and parenthetical auth options make it dense, but nearly every clause carries operational weight; only slight tightening is possible.

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 must describe returns — and it names the verdict values and the thin-liquidity/surge notes, which is adequate. It covers pricing, auth, and chains for what is a fairly complex paid tool, though it omits token input format and error behavior beyond the payment-required case.

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

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

Schema description coverage is 0%, so the description must compensate, and it mostly does: `token` is identified as the subject, `chain` is concretely scoped to eight named networks, and `api_key`, `payment`, and `bundle_token` are each explained as alternative auth mechanisms. It stops short of specifying token format, defaults, or required-vs-optional status, leaving minor gaps.

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

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

States a specific verb+resource ('Smart-money / DEX flow verdict for a token') and enumerates the signals returned (24h buy/sell pressure, liquidity, average trade size, activity-surge ratio). The accumulating/distributing/balanced verdict framing distinguishes it clearly from siblings like check_token_safety or get_base_wallet_intel.

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

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

Gives clear invocation context: it is a paid endpoint ($0.02), usable keyless or via `payment` header / prepaid `bundle_token` / free-tier `api_key`, with an explicit route to get_free_api_key to mint a key. It does not, however, state when to prefer this analytical verdict over alternatives such as check_token_safety, so no explicit exclusions are offered.

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 behavioral disclosure burden. It explicitly reveals the most important quirk: the tool returns a payment requirement until a payment/bundle_token/api_key is supplied. It also discloses cost and the broad shape of returned data. It stops short of rate limits or exact response contracts, but the core gate behavior is 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 description is compact and front-loads the cost and endpoint, followed by data scope and authentication behavior. Every sentence adds information, except possibly 'Verdict-shaped output', which is ambiguous and contributes little without elaboration.

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 there is no output schema and no annotations, the description should fully explain both return behavior and invocation details. It covers the data categories and auth options, but 'verdict-shaped output' is underspecified, and the relationship between a `payment` header and the schema's `payment` property is unclear. The tool is selectable, but not fully invocable without 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 0%, so the description must compensate, and it mostly does. It explains the semantic roles of all three parameters: payment, prepaid bundle_token, and free-tier api_key, including how to obtain a free key via get_free_api_key. It does not specify formats or whether these are headers versus input properties, but the purpose of each parameter is clear.

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

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

The description clearly identifies the resource: 'Stellar on-chain pulse' and names the data areas delivered (ledger health, XLM supply stats, 1h XLM/USDC SDEX trade statistics). It is specific enough to distinguish from sibling tools like get_xlm_sentiment or get_xlm_quote, though 'Verdict-shaped output' is vague and weakens precision.

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 guidance about when to choose this tool over siblings, no exclusions, and no mention of the alternatives for sentiment or quotes. The description only provides authorization preconditions ('PAID $0.10 per call', needing payment, bundle_token, or api_key), which is usage context but not tool-selection guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose a significant operational trait: the call is paid, and the API returns a payment requirement unless one of three credentials is supplied. It also points to get_free_api_key for obtaining a free-tier key. Missing are rate limits, error behavior, and explicit confirmation that this is a read-only operation.

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

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

The description is compact—two sentences—and front-loads the most important information: the paid nature and the data provided. The payment sentence is dense but efficient. It loses a point because the second sentence is slightly convoluted with three alternative auth methods and the inline code, making it harder to parse at a glance.

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

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

Given the absence of annotations and output schema, the description covers the essential invocation details: cost, endpoint, data returned, and three credential alternatives. It is not fully complete because it omits error handling, rate limits, the structure/shape of the payment requirement response, and clear guidance on whether 'payment' is a header or a 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 description coverage is 0%, so the description must give meaning to the parameters. It does attach roles: api_key, payment, and bundle_token are alternative ways to satisfy the payment requirement, and api_key can be a free-tier key obtainable from get_free_api_key. However, it does not describe value formats, requiredness, or how 'payment' should be serialized, and it confusingly calls it a 'header' while the schema exposes it as a string property.

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

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

The description clearly identifies the resource (XLM/USD price) and the concrete outputs (best bid/ask, mid, spread, depth), making the tool's purpose evident. It does not explicitly name or contrast sibling tools, and it lacks a direct action verb like 'retrieve' or 'get', 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?

The description provides clear context for when this would be useful—live XLM price and SDEX order-book data—and explains the payment/authentication requirements. However, it does not tell the agent when to prefer this over related tools like get_attested_quote or other market-data siblings, so usage guidance is mostly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states the operation is read-only via 'get', specifies the output is a JSON string, and lists the exact returned keys, including a timestamp and per-component breakdown. It could add more about potential rate limits or error conditions, but for a zero-parameter read endpoint this is strong disclosure.

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

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

The description is two sentences, front-loads the key purpose and cost signal, and then provides the output format in a compact, scannable list. Every sentence adds useful information without redundancy.

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

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

Given zero input parameters, an output schema, and a clear list of returned fields, the description gives an agent everything needed to invoke the tool correctly. The live-price and spread details further clarify what kind of snapshot this endpoint provides, making the context complete for its simplicity.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The description appropriately focuses on output semantics, which is all the agent needs to understand the call. This matches the baseline 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 clearly states the tool returns a composite XLM market sentiment score in [-1, 1], identifies the bullish interpretation, and lists additional outputs like per-component breakdown, live price, and spread. This distinguishes it from sibling tools such as history or report variants by emphasizing current composite sentiment plus market data.

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

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

The description implies the tool is for retrieving a current XLM sentiment snapshot, especially with 'live XLM price' and a timestamp field. However, it does not explicitly state when to prefer this over alternatives like get_xlm_sentiment_history or get_xlm_sentiment_report, nor does it provide any exclusion criteria.

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

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

The description discloses the payment gating behavior (returns a payment requirement until provided with payment, bundle_token, or api_key), which is a key behavioral trait beyond the name. With no annotations, it partially covers the safety/access profile but omits details like rate limits, error handling, or exact output format, which the description alone should carry.

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

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

Two sentences with no filler. It front-loads the price and URL, states the default, and covers authentication paths efficiently. Every sentence earns its place.

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

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

For a tool with no output schema, the description should clarify what the return contains beyond the high-level 'hourly trend series'. It covers payment and default hours but lacks specifics on response structure, edge cases (e.g., invalid hours, limits), and error behavior. Since annotations are absent, this is a noticeable gap, though the core calling requirements (auth, hours) are present.

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

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

Schema coverage is 0%, so the description must explain parameters. It does: hours (default 24h), payment (payment header), bundle_token (prepaid), and api_key (free-tier). This adds meaningful semantics beyond the schema's bare string fields, though it doesn't provide constraints like valid hour ranges.

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

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

The description clearly states the tool returns an hourly XLM sentiment trend series (Fear & Greed + momentum, order-flow overlaid) with a default 24h window. This specific verb-resource combination distinguishes it from siblings like get_xlm_sentiment (current value) and get_fear_greed_index (index), making the purpose unambiguous.

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

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

It provides context on payment requirements and mentions that a free-tier api_key can be minted via get_free_api_key, guiding authentication. However, it does not explicitly state when to prefer this over siblings (e.g., when a time series is needed vs. a current snapshot), leaving some inference to the agent.

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 present, so the description carries the full burden. It discloses the $0.25 cost, the auth options (payment header, bundle_token, free-tier api_key), and the gate behavior: 'Returns a payment requirement until called with...' This is meaningful context beyond the schema. It does not cover rate limits or error behavior beyond the payment gate.

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

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

Two sentences with no filler; the cost is front-loaded and the output contents are listed compactly. The second sentence is long but dense, covering auth and gate behavior. Structure is efficient, though the run-on could be split for 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?

The description provides cost, auth routes, and output fields, enough to attempt a call, but leaves ambiguity: it refers to a 'payment header' while the schema exposes a `payment` property, and it doesn't clarify whether parameters are passed as body fields or headers. No output schema exists, so a fuller statement of the success response shape would help. Overall adequate but with key gaps.

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

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

With 0% schema description coverage, the description compensates by explaining the role of all three parameters: `payment` header, prepaid `bundle_token`, and free-tier `api_key` (mintable via get_free_api_key). This clarifies that they are alternative authentication methods, which the bare schema does not convey. It stops short of specifying header names or precedence.

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: 'full XLM sentiment report' with enumerated components (Fear & Greed, order-flow imbalance, 24h momentum, directional verdict, live price, arbitrage context). It does not explicitly name sibling tools like get_xlm_sentiment, relying on 'PREMIUM'/'full' to imply differentiation.

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

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

The description implies usage by labeling the tool 'PREMIUM: full XLM sentiment report' and pointing to get_free_api_key for minting a key, but it never directly states when to choose this over get_xlm_sentiment or get_xlm_sentiment_history, nor does it provide exclusionary 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 provided, the description carries the full burden and adds meaningful behavioral detail: the call is paid, requires a payment header, bundle_token, or api_key, and will return a payment requirement until authenticated. It does not explicitly state whether the operation is read-only, but it discloses the most important non-obvious behavior.

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

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

The description is compact and front-loads the price and core purpose before the auth details. Minor redundancy exists between the title's '$0.10' and the opening 'PAID $0.10 per call', but no sentence is wasted.

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

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

The payment/auth flow is well covered, but the tool has no annotations, no output schema, and five undocumented parameters, and the description fails to explain period and tickers or describe the response format. An agent would still struggle to construct valid invocation arguments.

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

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

Schema description coverage is 0%, so the description must compensate for all five undocumented parameters. It only clarifies payment, bundle_token, and api_key; the functional parameters period and tickers are never explained, leaving the agent without guidance on what values to provide.

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 and resource: 'Strategy screen across 8 major assets' with concrete outputs ('trailing return vs buy-and-hold, momentum and a ranked verdict per asset'). This clearly distinguishes it from the get_* sibling market-data tools and avoids any tautology.

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 conveys usage context indirectly by describing what the tool screens and by explaining the required payment/auth setup, including a pointer to get_free_api_key for minting a key. However, it never explicitly says when to choose this tool over sibling screening or market-data tools, nor lists any exclusions.

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