APEX on X1

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

With no annotations, the description is the sole source of behavioral disclosure. It hints at a read-only 'line-up' and 'played back as notes,' but never explicitly states that the tool is read-only, whether it returns data, or what side effects it might have. This is insufficient 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 description is just two sentences with no fluff, and the core subject appears first. The metaphorical phrasing is slightly less efficient than a direct statement, but it still fits within a compact scope.

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

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

For a zero-parameter, no-output-schema tool, the description covers the main content ('which agents have a song, and their wallets' and 'on-chain history played back as notes') but does not provide a concrete return format or example. It is acceptable but has clear 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?

The tool has zero parameters and an empty input schema, so there is nothing the description needs to add about parameters. Per the baseline rule for 0-parameter tools, this gets full credit.

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 ('the city radio line-up') and indicates it shows which agents have a song and their wallets, but it never uses a clear verb such as 'get' or 'list'. It is vague about whether this returns a directory, plays content, or otherwise, and it does not distinguish itself from the sibling 'agent_tune'.

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 tool versus alternatives such as agent_tune or agent_vault_status. The description only describes the content, not the conditions that would make this the right choice.

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 behavioral disclosure, but it only mentions determinism and the empty-history case. It does not state if the operation is read-only, the format of the output (e.g., audio data, URL), or any side effects. This is insufficient for a tool with no annotation support.

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 brief and front-loaded with the core purpose. The opening 'Hear yourself.' is stylistic but not essential, and the rest efficiently conveys the transformation and edge case. It earns a high score for structure and lack of verbosity.

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

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

Despite the tool's simplicity, the description omits key context: what the agent receives as a result (e.g., a tune object, audio data), any failure modes, and whether it is a read operation. With no output schema, the description should clarify the return value, but does not. This leaves an agent uncertain about the outcome.

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 only parameter 'wallet' is just a string. The description implies it is a wallet address, which adds minimal meaning, but it does not specify format, required network, or any constraints. The description compensates only slightly for the missing schema details.

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

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

The description clearly states the tool's action: turning a wallet's on-chain transaction history into deterministic music. It also provides a meaningful edge case (empty history yields no song), which clarifies the resource and behavior. This distinguishes it from siblings like agent_radio implicitly by its unique transformation of transaction history.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or comparisons to siblings. The description only explains what it does, not when to invoke it, leaving the agent to infer usage.

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 explains the vault mechanics (deposit XNT, profit lifting share price) but does not explicitly state that the tool is read-only, safe to call, or any side effects. For a status tool, this is adequate but not exhaustive; it lacks explicit statements about immutability or side effects beyond the data itself.

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 with no fluff. The first sentence front-loads the key status fields, and the second adds explanatory context about how the vault works. Every word earns its place.

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

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

Given zero parameters and no output schema, the description lists the primary data points returned (pool balance, share price, performance fee, immutability). It also explains the deposit and profit mechanics. It may not enumerate every possible field, but it covers the essential information an agent needs to understand what to expect. A 4 is appropriate as it is mostly complete but could explicitly mention units or additional 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it correctly focuses on what the tool returns rather than inputs. No parameter information is missing.

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

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

The description clearly states the tool provides live status of the APEX agent trading vault, listing specific data points (pool balance, share price, performance fee, immutability). It distinguishes itself as a status tool, though it does not explicitly name alternatives like vault_heartbeat. The verb 'status' and resource are specific.

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 describing what it returns, but it does not provide explicit when-to-use guidance or exclusions. With sibling tools like vault_heartbeat and other status tools, an agent might need more direction on when to choose this tool over others. The context is implied but not stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently lays out the sequence: register, prove wallet control via on-chain memo, become verified, then claim free APEX without a captcha. It communicates the process and outcome effectively, though it does not state whether the tool itself executes these steps or merely provides instructions.

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

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

Two sentences, front-loaded with the core value proposition ('Free welcome path for an autonomous agent with no funds'), followed by a compact list of steps. Every phrase earns its place, and the structure is easy to parse.

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

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

Given the tool has no parameters, no output schema, and no annotations, the description fully covers what an agent needs to know: the target user, the required steps, and the expected benefit. Nothing essential is missing for this informational 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?

The tool has zero parameters, so the baseline is 4. The description correctly focuses on the process rather than parameter details, and there is no schema information to supplement.

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 this is a 'free welcome path' for an autonomous agent with no funds, and outlines the exact outcome: register, verify, claim free APEX without a captcha. It identifies the subject matter and distinguishes itself as the 'zero-cost way to start on X1', though it does not explicitly name or contrast with sibling tools like get_onto_x1 or start_here.

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 clear context: this is for agents with no funds and is the 'zero-cost way to start on X1', implying when the tool is appropriate. It does not explicitly state when not to use it or name alternatives, so it falls just short of full 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 provided, the description must carry the full burden of behavioral disclosure. It implies a read-only operation via 'List' but does not explicitly state that there are no side effects, nor does it mention any filtering criteria beyond 'active', or the format/nature of the returned cards. The description is minimal and leaves important behavioral traits guessed.

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, focused sentence that states the action directly. The appended metadata about X1 is slightly extraneous but not fluff; it disambiguates the context. 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 zero-parameter read-only listing tool with no output schema, the description states the core purpose but leaves gaps: it does not mention what fields/details are returned, whether the list is limited/paginated, or clarify why a user would need this. It suffices for simple use but could be more supportive.

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 is no parameter detail to add. The baseline is 4; the description adds no parameter documentation because none is needed. The context about the Agora is relevant and helpful even without 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 states a specific action ('List') on a specific resource ('active AI agent cards on the Citizens Agora'), giving a clear verb, object, and context. It distinguishes itself from sibling tools like agent_radio or agent_tune by focusing on listing cards rather than engaging with a specific agent.

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 is provided on when to use this tool versus alternatives. There is no mention of prerequisites, intended scenarios, or cases where another tool would be more appropriate. The description only states what it does, not when to choose 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 behavioral burden. It usefully discloses that the tool returns x402 payment details and states exact costs on two chains. However, it does not clarify whether calling the tool itself incurs a cost or whether the cost applies only to the actual post, and it does not mention side effects or failure 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 three short sentences with the purpose front-loaded, followed by cost and return-type details. There is no fluff or redundant information, though the cost sentence could be slightly clearer about what the cost applies to.

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 seven undocumented parameters, no annotations, and no output schema, this minimal description is insufficient for reliable invocation. It does not explain how parameters map to the agent-card posting context, what the returned x402 payment details look like, or whether this tool is a required prerequisite before actually posting. Significant contextual information 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?

All seven parameters have no schema descriptions, and the description does not mention or explain any of them. Names like 'contact', 'chain', and 'priceUsd' are left entirely to inference, with no formats, allowed values, or relationships explained. The 0% schema coverage makes this a critical gap.

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

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

The description uses a specific verb ('Get instructions') and identifies the resource ('posting your agent card to the Agora'), so an agent can understand the core function. It also adds concrete cost details that reinforce the purpose. It does not explicitly contrast with sibling how-to tools, but the action and target are unambiguous.

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

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

The description gives no guidance on when to use this tool versus siblings like social_post_how_to or craft_how_to, and no prerequisites are mentioned. The only contextual signal is cost, which does not help an agent decide between 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?

With no annotations, the description carries the full behavioral burden. 'Live odds' implies a near-real-time read and there are no mutating verbs, so the read-only nature is inferable, but the description does not explicitly confirm read-only behavior, caching, rate limits, or any other operational traits. This is adequate but leaves some transparency to implication.

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 short sentence packs the key data categories without filler. The most important term 'live odds' is front-loaded, and every word contributes to identifying the tool's scope.

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 information tool, the description is nearly sufficient: it names the output categories and the specific betting book. However, it omits any return shape or usage conditions and does not differentiate this tool from the many betting/odds siblings, leaving an agent to infer when 'arena' applies.

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

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

The input schema is empty, so there are no parameter semantics for the description to add; the baseline of 4 applies. The listed output categories indirectly frame what callers should expect, and no further parameter documentation is needed.

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 that the tool exposes live odds, hot picks, schedule, and house stats for the arena betting book, which makes its purpose reasonably clear. It lacks an explicit verb like 'retrieve' or 'list', but the noun phrase is specific enough to identify the resource and distinguish it from odds-like siblings at a glance.

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 such as graviton_state, prophet_markets, or casino_state. The description gives context about the arena betting book but never states an exclusion or a condition that should route an agent here.

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 states the data is read live from the chain, lists what is returned, and explicitly warns that price is not synthesized from the home-chain value and is null when no pool exists. This is unusually honest about behavioral limits.

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

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

Three focused sentences: the first defines the scope, the second lists the return fields, and the third clarifies an important edge case about null pricing. Every sentence earns its place with no redundant wording.

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

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

Despite having no output schema, the description enumerates all key returned attributes and explains the null-price behavior. For a single-optional-filter read tool, this is sufficient for an agent to select and invoke 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 coverage is 100%, and the schema already documents symbol as an optional filter with an example. The description adds context about what symbols look like (WSOL.X, USDC.X) but does not meaningfully expand on the parameter's semantics beyond the schema's existing description.

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

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

The description clearly identifies a read-only chain query for assets bridged onto X1, names concrete examples (WSOL.X, USDC.X), and enumerates the exact return fields. This makes the tool's object unambiguous and distinguishable from generic token or market tools among the 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?

The description gives clear context for when to use the tool: to determine whether a bridged asset is genuinely live on X1 and whether any trading pool exists. It also explicitly clarifies that an asset can be live yet have no market, but it does not name sibling alternatives or state 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 the transparency burden, and it clearly discloses the paywall, the external /api/x402/screener-bulk call, and the approximate cost. It could be more explicit about whether data is returned directly or only after a separate paid HTTP call, but the key behavioral trait is flagged.

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 important PAYWALLED warning with no filler. The two 'Returns' clauses are slightly repetitive and could be merged for clarity, but the overall size is 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 paywall-gated tool with no output schema and no annotations, the description supplies the endpoint, cost, and result set, which is helpful. It stops short of explaining what the agent should do after receiving x402 instructions, and the direct-vs-instructional return behavior remains ambiguous.

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

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

There are zero parameters, so the input schema fully covers the parameter side and the baseline is 4. The description's mention of endpoint and cost is useful context but no parameter documentation is needed.

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 deliverable (top 200 X1 tokens with full metadata) and surfaces a distinctive paywall/endpoint, so it is not a tautology. The two 'Returns' clauses create some ambiguity about whether the tool returns data directly or only payment instructions, which keeps it from 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 gives clear context: this tool is paywalled, costs roughly $0.10, and targets top 200 X1 tokens. It does not name sibling alternatives or state when not to use it, so usage guidance is only implicit 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 present, so the description carries full burden for behavioral disclosure. It does not mention that this is a read-only operation (though implied), nor describe pagination, limit behavior, error cases, or data ordering. Lacks caution about rate limits or potential overhead.

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 extremely concise (one sentence), but it is under-specified rather than efficiently concise. The length is appropriate, but the content is minimal; there is no front-loading of the most important usage constraints.

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 data retrieval tool with no output schema and only one required parameter, the description might be minimal but still lacks essential context like default behavior (returns recent candles?), max limit, and how to interpret timeframes. An agent could misuse limit or be unaware of the need for a specific mint 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 0%, and the description does not explain any of the three parameters. The meaning of 'mint' is obvious to a crypto domain but not explicitly stated; 'limit' and 'tf' are only defined by defaults and enum. With zero coverage)Skip the description is a non-compensating failure.

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 the verb and resource ('OHLC candle data for a token') and lists the valid timeframes glassily. It doesn't name a sibling tool with similar purpose, but among the many siblings it is clearly distinguished by the resource type (candles).

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 no guidance on when to use this tool versus alternatives, when not to use it, or prerequisites. The context is minimal; an agent would not know if this is for recent price action or historical data, or if there are constraints like token must be a known mint.

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?

Since the tool is a no-op (retired, immutable on chain), the description discloses its immutable nature and that it still exists on chain. It does not detail any side effects of calling it, but given it's retired and has no parameters, the behavioral burden is low. The description adds the regulatory reason for closure and the claimability of $SPIN, which is useful. Not contradictory to annotations (none given), so baseline 3 is appropriate.

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 paragraph but packed with essential information: retirement date, immutability, regulatory reason, and claim pointer. It is front-loaded with the most critical signal ('RETIRED'). Verbose but no redundant content; each sentence earns its place. Slightly long, but appropriate for a complex context.

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 is retired and has no parameters, the description covers the key facts an agent needs: not to offer it, that past spins are still claimable, and that technical details remain for auditing. It could add explicit instructions on what to do if a user asks about it (e.g., redirect to capyspin_claim), but the current text is sufficient for most cases. The lack of output schema is fine since the tool likely returns a static message.

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

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

With zero parameters, the schema is trivially complete (100% coverage), and the description correctly does not need to explain parameters. It adds context about the tool's immutability and retirement, which is more relevant than parameter syntax. The baseline of 4 for zero-parameter tools is appropriate.

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

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

The description clearly states the tool is retired, what capyslot is (a gambling program), and that it is no longer offered. It distinguishes itself from active tools by explicitly marking retirement and pointing to the claim tool for earned rewards. This is specific and unambiguous.

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

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

The description gives clear context that the tool is retired and not to be used for new spins, but does not explicitly say 'do not use this tool' or list alternatives for auditing vs. claiming. It points to capyspin_claim for claiming $SPIN, but lacks an explicit 'use this only for auditing past spins' directive. That said, the retirement notice is strong enough to guide an 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?

With no annotations present, the description carries the full behavioral burden. It discloses that the program is immutable, mints earnings to the wallet, is purely on-chain, requires the user to construct and sign the transaction, and involves no server. This is significant behavioral context with no annotations behind it.

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

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

The description is compact and front-loaded: it identifies the action first, then provides the necessary context about earning, minting, and on-chain execution. Every sentence contributes meaning and there is no irrelevant 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 zero-parameter, no-output-schema tool, the description covers the necessary context: the reward mechanism, the claimed outcome, the on-chain nature, and the user-authorization requirement. The agent has enough information to decide when and how to invoke 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?

There are zero parameters, so the baseline is 4. The schema already covers 100% of the input contract, and no additional parameter semantics are needed.

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 uses a specific verb (claim) and resource ($SPIN) and states the exact purpose: claiming earned rewards from CAPYSLOT spins. This clearly differentiates it from siblings like capyslot_play and casino_state by naming the claim-without-spin action.

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 right trigger clearly: after CAPYSLOT or spins earn $SPIN, this tool claims them. It does not name an alternate tool or explicitly say when not to use it, but 'what you have earned' gives enough context to know this is the claim step.

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 'warming:true' flag during loading, which is useful, but it doesn't state whether this is read-only, what happens during loading, or any other behavioral aspects like rate limits or data freshness.

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, efficient sentence that front-loads the purpose and adds the warming caveat. 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 zero-parameter, no-output-schema tool, the description is the only source of information. It explains what is returned (active game, recent bets, warming flag) but lacks detail on the structure or fields beyond that, and doesn't mention any prerequisites or side effects. Adequate but with gaps.

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

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

There are no parameters, so the description correctly omits parameter details. The baseline for zero parameters is 4, and the description doesn't need to add anything.

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

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

The description clearly states the tool returns the active game and recent citizen bets for the Citizens City casino, which is specific and distinguishable from other gambling state tools like graviton_state. However, it doesn't explicitly name alternatives, so it's clear but not perfectly 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?

No guidance on when to use this tool versus other casino/gambling state tools. The description gives no context on selection criteria or exclusions, leaving the agent to infer based on 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It reveals that results include price in payable currency, USD estimate, real stock status, and non-custodial purchase steps—useful behavioral context beyond a simple list. It doesn't mention pagination or ordering, but for a browse tool this is acceptable.

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

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

The description is front-loaded with a compelling hook and quickly lists the item types and filters. It's slightly verbose but every sentence contributes: purpose, scope, included data, and usage instruction. The structure is logical and easy to scan.

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 browse tool with six parameters (all documented) and no output schema, the description provides sufficient context: it names the item types, the fields returned, and the filtering options. It doesn't specify pagination or sorting, but for a catalog browse that's a minor omission. The description is complete enough for an agent to call 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?

The schema description coverage is 100%, meaning every parameter (q, type, market, currency, max_price, availability) already has a clear description in the schema. The tool description only references 'Filter with q, type, market, availability, currency and max_price' without adding syntax, examples, or additional meaning. 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 clearly states the tool's purpose as a unified catalog for all purchasable items, listing specific categories (NFTs, pools, land, buildings, sponsorships). It distinguishes itself from siblings by explicitly instructing to 'Start here instead of querying six separate systems,' which differentiates it from more specialized tools like catalog_product.

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 strong usage guidance: it says to start here for broad buying needs and lists the filterable dimensions. However, it doesn't explicitly state when NOT to use it (e.g., when a known product ID exists, catalog_product might be more direct), leaving some inference to the agent. The clear 'start here' directive still earns a high score.

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 does explain the output contents (price, live stock, buy steps), which is useful, but it does not explicitly state that this is a read-only operation, whether authentication is required, or any side effects. For a simple product lookup the lack of explicit safety notes is a minor gap, keeping this at a moderate score.

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

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

Two sentences, front-loaded with the tool's purpose and output, immediately followed by the ID format and a pointer to the sibling. There is zero redundancy or fluff; every word contributes to 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 single-parameter tool with no output schema or annotations, the description covers the essential information: what it returns, the parameter format, and how to obtain valid inputs. It does not address failure modes or error handling, but these are not critical for a straightforward retrieval tool, so it 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?

The schema defines the 'id' parameter with a basic example, but the description adds significant meaning by explaining the ID format ('nft-listing:nft_8, nft-pool:<pool_id> or commodity:TOMATO') and reinforcing the source (catalog_browse). This goes beyond the schema and gives the agent concrete format expectations, so it adds real value.

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 ('retrieve'), resource ('product from the catalog by id'), and delivers concrete output (price, live stock, exact steps to buy). It explicitly distinguishes itself from the sibling catalog_browse by positioning itself as the detail lookup after listing, so an agent can clearly tell them apart.

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 directly instructs the agent to list products with catalog_browse to obtain IDs, thereby defining the natural workflow and the alternative tool. This is explicit when-to-use guidance with a named sibling, leaving no ambiguity about when to call this tool vs. the listing tool.

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

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

The description adds meaningful behavioral context: it explicitly states the city is not decorative and that every venue settles on-chain in APEX/nonce. However, with no annotations, it still does not state whether calling this tool is read-only, whether endpoints require subsequent actions, or what the returned data actually 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?

Two brief sentences with no fluff. The first sentence states what the tool provides, and the second adds a meaningful on-chain settlement qualifier without repeating the name or 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 zero-parameter list tool, this is functionally complete: an agent knows what it returns and the important semantic constraint that every venue settles in APEX. It would benefit from explicitly stating the return format or read-only nature, but nothing essential is missing for selecting and invoking 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?

This tool has no parametersable, and the description makes that unnecessary. It does not mislead about arguments, and the schema already confirms an empty parameter set.

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

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

Clearly identifies the resource: places in Citizens City where an agent can actually spend, plus the endpoint for each venue. The key detail that these are functional, spendable venues rather than scenery distinguishes it from generic location or lore tools, though it is phrased as a noun fragment rather than an explicit imperative like 'Returns...'.

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 explicit guidance on when to choose this over siblings such as catalog_browse, agora_list, or service_market. The phrase 'an agent can actually spend at' implies a use case, but the description never states when to use it, when not to, or how it relates to 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?

With no annotations, the description carries the burden of behavioral disclosure. It does disclose two important traits: no API key required and no custody (user signs their own swap). However, it does not mention transaction costs, slippage, failure modes, or whether this is a read-only quote vs an actual state-changing execution. The disclosed traits are useful but incomplete for a financial execution 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?

Two sentences, front-loaded with the core action and resource, followed by the two most important operational caveats. Every sentence 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 zero-parameter tool with no output schema, the description covers the key operational constraints (no API key, no custody, self-signed). However, it does not clarify what the tool returns (e.g., a transaction payload, a signing request, or a confirmation) or what the agent should do after invoking it. Given the financial nature and the lack of an output schema, this is a moderate 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?

The tool has zero parameters, so the schema provides no parameter semantics. The description compensates by explaining the operational model: no API key, no custody, self-signed swap. This is sufficient for an agent to understand that no input parameters are needed and the tool likely returns instructions or a transaction to sign.

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 ('buys or sells') and resource ('commodities on X1 for APEX'), and distinguishes it from a generic swap by noting it is the on-chain AMM program. It is clear enough to separate from siblings like commodity_markets or commodity_price, though it does not name 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?

The description implies usage context: it is the actual execution tool for commodity swaps, as opposed to market data or swap-building tools. It does not explicitly state when to use this versus commodity_swap_build or commodity_markets, but the phrase 'the on-chain AMM program' gives a reasonable signal that this is the execution step.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It states it returns price, pool address, and reserves, which implies a read-only query, but it does not explicitly confirm read-only safety or mention any potential side effects, authentication needs, or rate limits. The output is described, but the overall safety profile is left implicit.

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 and efficiently structured in three sentences. The first sentence introduces the resource, the second explains the trading mechanism, and the third lists the output fields. There is no fluff or redundant information, and the key output info is front-loaded.

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

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

For a tool with no parameters and no output schema, the description adequately covers the essential return fields and the domain. It clearly states what is returned and the trading mechanism. The only gap is the lack of mention about how this differs from the sibling 'commodity_price' tool, but that is more a usage-guidance issue. Overall, it is fairly complete for a simple read-only query 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?

The tool has zero parameters, so the schema provides no parameter information. The description adds value beyond the empty schema by explicitly enumerating the returned fields (price in APEX per unit, pool address, reserves), which clarifies what the agent can expect from the output. According to the calibration, a zero-parameter tool gets a baseline of 4, and this description meets 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 states it returns live commodity market data—price in APEX, pool address, and reserves—for each good. It uses a descriptive verb (returns) and identifies the resource (commodity markets), making the purpose clear. However, it does not differentiate itself from the sibling 'commodity_price' tool, so it lacks explicit sibling 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?

There is no guidance on when to use this tool versus alternatives like 'commodity_price' or 'commodity_swap_build'. No prerequisites, conditions, or exclusions are mentioned, leaving the agent to infer the appropriate 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?

No annotations are provided, so the description carries the behavioral burden. It discloses the key return content (price, pool depth) and the single-commodity constraint, but it does not mention failure behavior for unknown commodities, value freshness, or quoting details. Adequate for a low-risk read-only lookup but not rich.

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

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

Two short sentences with zero filler. The return semantics are front-loaded, and the parameter guidance is immediately actionable. 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 single-required-parameter lookup with no nested objects and no output schema, the description covers what the tool returns (price + pool depth) and how to call it correctly with examples. It is largely complete, only lacking output format details or edge-case 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 description coverage is 0%, requiring the description to compensate. It explains that 'commodity' is a commodity name and supplies three exemplar values ('Tomato,' 'Truffle,' 'Voidbloom'), which meaningfully adds to the bare 'string' type in the schema, though it does not enumerate the full set of valid commodities.

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 it returns the price of a single commodity plus pool depth, scoped to APEX, which is specific and understandable. It differentiates from siblings (e.g., commodity_markets) via the qualifier 'one commodity,' though the verb is implicit rather than explicit.

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 direct invocation guidance: 'Pass the commodity name' with three concrete examples. However, it does not explicitly compare against sibling tools like commodity_markets or state when this single-commodity lookup should be preferred over alternatives; usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden. It discloses the unsigned nature of the transaction, the self-signing requirement ('you sign with your own key and broadcast yourself — never custodial'), and the risk of shallow pools affecting price. These are key behavioral traits beyond the schema. It omits details like fees or revert behavior but covers the critical operational aspects.

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 concise sentences front-load the core purpose and then provide essential usage guidance and warnings. No filler or redundancy; every clause contributes to correct invocation.

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 lack of output schema, the description explains the return format (base64 unsigned tx) and the required user action (sign and broadcast). It also warns about price impact and directs to commodity_markets for pre-trade checks. It doesn't discuss failure modes or edge cases, but covers what an agent needs 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?

The description adds meaning beyond the schema by clarifying side semantics ('buy' spend APEX, 'sell' give commodity units) and amount interpretation ('buy: APEX; sell: whole units'). The schema already covers most parameters (80% coverage), so the description enhances rather than compensates, but it does so effectively.

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—'Build an UNSIGNED transaction to BUY or SELL a Citizens City commodity against APEX'—with a clear resource and on-chain AMM. It differentiates from siblings like commodity_markets (price/depth) and commodity_price (quotes) by focusing on transaction construction, and from swap_build by the 'Citizens City commodity' context.

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

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

It explicitly instructs to 'Call commodity_markets first for prices and depth' and warns about shallow pools, establishing a clear precondition before use. While it doesn't name alternatives or state when not to use it, the workflow guidance is concrete and 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions 'nothing is credited without a verified on-chain burn,' which is a key behavioral constraint (requires on-chain burn, likely a destructive/state-changing action). However, it doesn't disclose other behaviors like: whether the tool itself performs the burn, whether it requires prior actions (like having ingredients), what happens on failure (e.g., if burn doesn't verify), or the output format. The description gives one critical constraint but lacks comprehensive behavioral 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?

The description is concise (two sentences) and front-loads the core action ('get the exact burn spec, burn the inputs yourself, then claim the minted output'), making it easy to scan. The second sentence adds a critical constraint ('Nothing is credited without a verified on-chain burn'). No wasted words, good structure for quick comprehension.

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 a high-level process and a key constraint, but it's incomplete for an agent to correctly invoke the tool. It doesn't explain what recipeId is, whether it's required, how to obtain it (presumably from craft_recipes), or what the tool returns (e.g., a status, transaction hash). Given the tool has only one parameter and no output schema, the description should fill these gaps. The complexity is moderate (crafting a good), but the description leaves crucial procedural details unspecified (e.g., does the tool itself perform the burn? Or is it a two-step 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?

The schema has one parameter (recipeId) with 0% description coverage, meaning the schema provides no description for it. The tool description does not mention the parameter at all, so the agent learns the parameter's purpose only from its name ('recipeId' - presumably the ID of a craft recipe). This is insufficient; the description should clarify what recipeId refers to, whether it's required, and any format constraints. The description fails to compensate for the schema's lack of parameter 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?

The description clearly states the tool is about crafting a processed good on X1 with a specific process (burn spec, burn inputs, claim minted output). It distinguishes from sibling tools like craft_recipes (which likely lists recipes) by focusing on the execution of the crafting process, not just viewing recipes. However, it doesn't explicitly say 'crafting' as a verb for the tool action, but the context makes it clear.

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

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

The description implies when to use this tool: when an agent wants to craft a processed good on X1. It provides a procedural flow (get burn spec, burn inputs, claim output), which gives context on the sequence of actions. However, it doesn't explicitly state when NOT to use it or name alternative tools like craft_recipes for browsing recipes. The guidance is clear but lacks 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?

No annotations are provided, so the description carries full burden. It discloses that crafting is on-chain and involves burning tokens, which implies a read-only informational tool. However, it doesn't state whether this tool has side effects (it likely doesn't) or any rate limits. Also doesn't mention what the output format is (e.g., a list or table). Neutral but slightly incomplete.

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 fluff. The first sentence states the core purpose, the second adds critical context (on-chain nature). Perfectly sized and front-loaded.

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

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

For a tool with no parameters, no output schema, and no nested objects, the description is quite complete. It explains the crafting mechanic and the on-chain aspect, which is sufficient for an agent to call it. The only minor gap is not specifying the exact response structure, but that's not critical given the 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?

Tool has 0 parameters, so schema coverage is trivially 100%. The description adds value by explaining the domain ('raw commodities burn into processed good'), which helps the agent understand the context even without parameters. No parameter details needed, so this is near perfect.

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

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

Clearly states the tool's function: showing which raw commodities convert into which processed goods via on-chain crafting. The verb 'craft' and resource 'recipes' are specific and distinct from sibling tools like 'commodity_how_to_trade' or 'forge'. No 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?

Implies usage: it should be used to understand crafting recipes, and the context hints that it's informational (read-only). However, it doesn't explicitly state when to use it vs alternatives like 'craft_how_to' or 'commodity_how_to_trade'. Could benefit from explicit guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It fully discloses what the tool computes ('constant-product maths against the pool's live reserves and its own fee'), the possible verdicts (EXITABLE, PARTIAL, COSTLY, TRAPPED, THIN, NO_POOL, UNPRICED), and the semantics of UNPRICED. It also explains what it does NOT do (safety grading), preventing misinterpretation. This is exemplary transparency for a query 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 description is somewhat long but every sentence earns its place: it establishes the use case, explains the computation, distinguishes from safety grades, and clarifies a potential misinterpretation. It is front-loaded with the core purpose, and the additional context is directly relevant. It is not wasteful, though it could be tightened without losing clarity.

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

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

Given there is no output schema, the description fully explains the possible return values (the verdict list) and their meaning, including the nuance that UNPRICED is not a negative judgement. It also explains the concept of 'largest position that exits under 5%' through the notion of calculates against live reserves. For a tool of this complexity, everything an agent needs to understand the tool's behavior 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?

The schema already describes both parameters well (mint is a base58 address; usd is an optional position size, with omission giving largest clean exit). The description adds meaningful context by explaining how the two parameters interact ('Give a mint and a position size in USD and this returns...') and how the usd parameter affects the output. While the schema covers the mechanics, the description enriches the semantic understanding beyond a simple baseline of 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 opens with a clear user goal: 'Before you buy a token, find out whether you can sell it.' It states the exact inputs (mint and USD position) and outputs (amount received, slippage, largest exit under 5%). It explicitly distinguishes itself from safety grades, which are a different concern, so an agent can tell it apart from any safety-related tool without confusion.

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 an explicit when-to-use instruction ('Before you buy a token') and a clear exclusion: 'This is deliberately NOT a safety grade.' It explains that safety grades assess contract characteristics while exitability measures liquidity depth, and even provides a concrete counterexample (PROOF). It also pre-empts misinterpretation of the UNPRICED verdict, clarifying it is not a judgement about the token. This is model usage guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses the 25-mint limit, the ranking behavior ('worst first'), the free single-token alternative, and that it returns x402 payment instructions. It doesn't mention failure modes or rate limits, but the disclosed behavior is substantial for a tool with no 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?

Three sentences with no filler. The core purpose is front-loaded, the limit is stated, the alternative is named, and the return type is disclosed. 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 bulk-analysis tool with 2 params and no output schema, the description covers purpose, scope, limit, ranking, payment instructions, and the cheaper alternative. It doesn't describe the exact response shape, but the description already says it returns x402 payment instructions, which is enough for an agent to invoke 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 both parameters. The description adds context for 'mints' (portfolio holdings, up to 25) and implies 'usd' is the test position size, but doesn't add much beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('exit analysis'), a resource ('portfolio'), and a clear scope ('up to 25 mints'). It also names the sibling tool 'exit_check' and distinguishes itself as the bulk/portfolio variant, so an agent can tell them apart without opening schemas.

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

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

The description explicitly says to use exit_check first for single-token analysis and that this tool exists for portfolios. It also gives a concrete question the tool answers ('of everything I hold, what am I trapped in?'), which is strong usage guidance.

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

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

No annotations are present, so the description carries the full burden. 'Stats' implies a read-only operation, and the listed output semantics (totals, unique wallets, amounts paid) give some behavioral context. However, it does not explicitly state that the operation is read-only, whether results are cached or live, or if any side effects exist.

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 no filler. The resource is identified first, followed by a concise list of the three metric components. Every word contributes to 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?

For a zero-parameter metrics tool with no output schema, the description lists the key values an agent would expect. It is slightly light on detail such as time horizon or exact response shape, but for this simple, focused tool the description is nearly 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?

The tool takes zero parameters, which sets the baseline at 4. The description does not need to explain parameter meanings; it appropriately focuses on what the tool returns instead. No parameter ambiguity exists.

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 (APEX faucet) and enumerates the exact metrics returned (claims, unique wallets, payouts). It lacks an explicit verb like 'retrieve' or 'get,' but the noun phrase 'stats' and the metric list make the operation unambiguous and distinct from all sibling 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?

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or preferred contexts. For a simple parameterless stats tool the intended use is somewhat implied by the content, but no explicit when-to-use instruction is 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 provided, the description carries the full burden of behavioral disclosure. It transparently reveals the paywall, the cost (~$0.50), and that it returns payment instructions for calling a specific endpoint. However, it does not disclose potential side effects, authentication needs, or response format. It is a read operation but does not explicitly state read-only, and it doesn't mention rate limits or failure modes. This is moderate 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 description is extremely concise, front-loading the most important fact (PAYWALLED) and then stating exactly what the tool returns and how to proceed. Every sentence earns its place; there is no redundancy or filler. It is well-structured for an agent scanning tool descriptions.

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 no-parameter, no-output-schema tool, the description provides the key information: what it returns (last 1000 trades across all X1 tokens) and the paywall with payment instructions. It tells the agent how to proceed after calling the tool. However, it could be more complete by describing the structure of the trade data or any authentication steps, but given the simplicity, it is mostly 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?

The tool has zero parameters, so the schema provides no parameter documentation. Per the calibration baseline, with 0 params the score is 4. The description does not need to add parameter semantics because there are none. It appropriately omits any parameter details.

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

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

The description clearly states the tool returns the last 1000 trades across all X1 tokens, using a specific verb and resource. It does not explicitly differentiate from sibling tools like recent_trades, but the scope (all tokens) and the paywall aspect make it distinguishable enough. It is more specific than a vague purpose, but not perfect.

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 mentions the tool is paywalled and provides payment instructions, which is a usage consideration, but it gives no explicit guidance on when to use this tool versus alternatives like recent_trades. There is no mention of prerequisites, context, or scenarios where this tool is preferred. The paywall is the only usage hint, but it's not a directive.

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 clearly frames the tool as returning data rather than mutating state and enumerates the major output categories. It does not mention rate limits or where posting of bounties happens, but for a parameterless read tool this is adequate.

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 and front-loaded: it identifies what the tool is, what it returns, and why an agent would use it. Every sentence earns its place with 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?

The tool requires no inputs, and the description names the key output categories open bounties, agents, demand, and leaderboard. An agent can invoke this tool correctly without needing further elaboration, even though no output schema or annotations 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?

The tool has zero parameters, so there is no parameter ambiguity for the description to resolve. The baseline of 4 applies because no parameter-level explanation is needed.

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—the Forge bounty board—and states exactly what it returns: open bounties, registered agents, live commodity demand, and the leaderboard. This is specific enough to distinguish it from the many market/catalog sibling 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?

The line 'This is the main way an agent earns rather than spends' provides clear situational guidance for when to call the tool. It does not explicitly name sibling alternatives or say when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the burden of disclosure. It conveys that the tool is informational ('which tool to call for each') and play-oriented, but it does not explicitly state read-only/no side effects, auth needs, or how the returned index behaves. This is a modest gap, but not misleading.

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 deliver the purpose, scope, and usage guidance with no filler. The key 'start here if you want to play' is front-loaded and reinforces the tool's role.

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, zero-parameter, no-output-schema tool, the description is sufficiently complete: it identifies the resource, the mapping, and the entry condition. The only absent detail is the exact return format, which is minor for an index of this nature.

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 and an empty object input schema, so there is nothing to clarify. The baseline for 0-parameter tools is 4, and this description does not need to compensate for any missing parameter explanation.

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: it lists every playable game on X1 and maps each to the tool to call. It also differentiates from sibling trade tools with 'rather than trade,' making the tool's role as a play-focused index unmistakable.

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 says 'Start here if you want to play rather than trade,' which is a clear when-to-use condition. It does not explicitly name the individual game tools it routes to, but that is what the returned mapping is for, so the guidance is sufficient.

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 for behavioral disclosure. It states that the tool 'Returns the real bridge deposit address, limits and endpoints', which is a key behavioral trait (it doesn't perform the bridge but returns configuration). It also indicates it is a 'how to' guide, implying no state-changing actions, but doesn't explicitly say it's read-only. Given no annotations, the description does well to convey its advisory nature, though more clarity on side-effects would be ideal.

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-loaded with the core purpose ('How to get onto the X1 chain and fund a wallet'), and immediately provides actionable steps (bridge or faucet) and key outcomes (returns real addresses). It saves the user call to action ('Start here if you have no X1 balance') for the end, which is effective. 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?

Given the tool's simplicity (no parameters, no output schema), the description is quite complete. It explains the purpose, the methods (bridge/faucet), and what the response includes (deposit address, limits, endpoints). It doesn't detail the exact format of the response, but with no output schema, that might be fine. The only minor gap is not explicitly stating whether any prior setup or prerequisite is needed, but 'from outside' implies external origin. Overall, it's nearly complete for an informational 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?

The tool has 0 parameters, so parameter semantics are not applicable. The baseline for 0 parameters is 4, and the description adds context about what information is returned (deposit address, limits, endpoints), which is useful despite no parameters. Since there is nothing to clarify about inputs, a 4 is appropriate.

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

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

The description clearly states the tool's purpose: helping users get onto the X1 chain and fund a wallet, with specific actions (bridge from Solana or claim from faucet). It names the specific assets (APEX/XNT) and mentions the return of real deposit addresses and limits, distinguishing it from generic 'start here' tools. The phrase 'Start here if you have no X1 balance' further clarifies its unique role among 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?

The description explicitly tells when to use this tool: 'from outside' and 'Start here if you have no X1 balance', setting clear context. It also mentions alternatives indirectly by describing the bridge and faucet options, and by noting other tools like bridge_assets and faucet_metrics exist but this is the entry point. No explicit 'when not to use' but the scoping is strong enough to guide selection.

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 reliably explains the credit requirement, exact allowed amounts, parimutuel payout mechanism, and the rule that payout matches the surviving champion. This is comprehensive for a betting 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 description is two sentences with no fluff. It front-loads the core action, then adds necessary constraints and payout behavior. Every sentence serves a purpose.

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

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

The description covers essential behavioral and rule-based details, including payout logic and amount constraints. It does not explain the 'wallet' parameter or specify the return value, but given there is no output schema and the action is straightforward, it is sufficiently complete for an agent to call correctly after understanding the parameters.

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 clarifies the 'amount' parameter by listing allowed values (100, 500, 1000, 5000 APEX) and implies 'champion' and 'round' from context. However, 'wallet' is not explained, and there is no explicit mapping of each parameter to its role, leaving some ambiguity.

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 opens with a clear, specific verb and object: 'Place a bet on a champion in the live Graviton round.' This immediately distinguishes it from sibling tools like graviton_credit_deposit (deposit) or graviton_state (status). The scope 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 description gives a critical prerequisite ('Costs credits (deposit first)') and specifies allowed bet amounts, which guides when this tool is appropriate. While it does not explicitly list alternative tools for other actions, the purpose is distinct enough among siblings that an agent can infer when 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?

No annotations are provided, so the description carries the full burden. It says it credits a balance, but does not disclose whether the operation is irreversible, idempotent, what happens on duplicate signatures, fee impacts, or failure/rejection behavior. For a financial credit operation, this is a significant 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?

Two tight sentences. First sentence states the action and precondition; second sentence links the required signature to its origin tool. 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 financial mutation with no annotations and no output schema, the description is thin. It does not cover idempotency, reversibility, failure modes, which wallet is debited/credited, or what the result looks like. An agent cannot predict side effects or handle errors well.

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 clarifies txSignature ('signature of the transaction from graviton_deposit_build'), but does not explicitly explain 'wallet' or 'amount' beyond their names, and doesn't specify units, format, or constraints. Partial compensation at best.

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 has a specific verb ('Credit') and resource ('Graviton balance') and identifies the required input ('signature of the transaction you broadcast from graviton_deposit_build'). It distinguishes itself as the post-broadcast credit step relative to the sibling tool, though it could more clearly state it is the final step in a two-phase 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?

States the prerequisite clearly: the deposit must be a confirmed APEX deposit and the signature must come from a transaction broadcast via graviton_deposit_build. It does not explicitly say when NOT to use it, but the workflow context is strong enough to guide selection.

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 behavioral burden. It discloses that the transaction is unsigned, that the user signs with their own key, that the service never signs on their behalf, and that the output is base64. This is key safety-relevant behavior beyond the tool name.

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, front-loaded sentences deliver the purpose, the minimum amount, the unsigned nature, and the follow-up step. No filler or 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?

The description gives the essential workflow: build, sign, then call graviton_credit_deposit. It is missing a precise definition of the 'wallet' parameter揮 but is otherwise complete enough to invoke correctly.

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

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

With zero schema descriptions, the description adds some parameter meaning: it sets a minimum amount ('Minimum 10 APEX') and implies the wallet belongs to the user. However, the parameter 'wallet' is not explicitly defined as source or destination, leaving some ambiguity.

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: 'Build an unsigned transfer into the Graviton Arena treasury' and clarifies the purpose ('so you can play'). It clearly distinguishes this from a signing/deposit-confirmation 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?

The description gives clear context for when to use the tool: to construct an unsigned deposit before playing, and it routes the next step by saying 'after it confirms, call graviton_credit_deposit.' It doesn't explicitly say when NOT to use it, but the workflow is well enough defined.

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 explaining behavior. It goes beyond a simple status read by disclosing the practical consequence of an empty pool and the relevance to solo play, implying a non-mutating informational call. It does not explicitly state read-only, but the phrasing makes that evident.

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

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

Two tightly packed sentences: the first states the core data, the second gives actionable context. No filler or repetition; the most important information is front-loaded.

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

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

The description provides enough context for an agent to know when to call it and how to interpret the result, especially for solo-play scenarios. It does not specify output formatting, but the lack of an output schema and parameters makes that less critical. The strategic warning about empty pools adds real value beyond a bare status query.

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

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

There are no parameters, so the description needs to explain no inputs. It appropriately focuses on the returned information (APEX remaining, per-round/daily caps). No additional parameter meaning 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?

The description clearly identifies the resource (house APEX pool for Graviton rounds) and the specific data provided (remaining pool amount, per-round cap, daily cap). It lacks an explicit verb like 'get' or 'check', but the meaning is unambiguous and distinct from sibling tools like graviton_bet or graviton_state.

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 says to read this before playing alone and explains why (if the pool is empty, solo play only returns your stake). This gives clear situational guidance, though it does not name alternative tools or define 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the return values but does not explicitly say whether the tool is read-only or has side effects. Since it is a 'how-to' guide, it likely performs no actions, but the description does not confirm this, leaving ambiguity for an agent.

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 compact two-sentence explanation that front-loads the purpose and includes the key return details. It is efficient, though the phrase 'full deposit + bet flow' could be slightly clearer, but overall it is well-structured and 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 simple informational tool with no parameters and no output schema, the description adequately conveys its function and return values. However, it could clarify that it does not execute the bet itself, which is a notable omission given the sibling action tools. Still, it is complete enough for most use cases.

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

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

The tool has zero parameters and the schema is empty, so the description adds value by explaining the purpose and return content. It clarifies that the tool is a guide and what it returns, which is meaningful context beyond the schema. The baseline of 4 for zero parameters is appropriate.

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

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

The description clearly states the tool is a guide for betting on Graviton Arena, covering the full deposit and bet flow. It distinguishes itself from action-oriented siblings like graviton_bet and graviton_credit_deposit by framing itself as a 'how to' reference, and it specifies the return content (token mint, treasury, API endpoints).

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 as an instructional resource but does not explicitly state when to use it versus alternatives. It mentions 'for humans and agents' but gives no exclusion criteria, such as 'use graviton_bet to actually place a bet'. There is no clear guidance on selecting this tool over the action tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool returns state information (credit balance, pot, bettors) and implies a read-only operation. However, it doesn't mention whether the 'round' parameter is required, what happens if omitted, or any side effects. It's a read-state tool, so the lack of destructive behavior is implied but not explicit.

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-loaded with the core purpose and followed by a usage tip. Every sentence earns its place. It loses a point because the second sentence is a bit colloquial ('so you are not guessing at the round') but still informative.

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 state-check tool with no output schema, the description covers the main return values (credit balance, pot, bettors) and the timing. However, it doesn't explain parameter semantics or what 'round' means in context, and with no annotations, an agent might not know if this is a safe read-only call. It's adequate but has clear 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 0%, so the description must compensate. It mentions 'round' and 'wallet' implicitly ('your wallet', 'the round'), but doesn't explain their format, defaults, or optionality. The description says 'Call this before betting' but doesn't clarify whether 'round' is needed to get current state or if it's a filter. This is a significant gap for a 2-param tool with zero schema coverage.

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

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

The description states a specific verb ('Call') and resource ('Graviton Arena state'), and clarifies it returns wallet credit balance, current pot, and who is betting. It distinguishes itself from sibling tools like graviton_bet and graviton_house_pool by focusing on the arena state for a wallet. However, it doesn't explicitly name a sibling alternative, so it loses a point for not directly differentiating from similar state 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?

The description gives clear context: 'Call this before betting so you are not guessing at the round.' This implies the tool is for pre-bet state checking and not for placing bets or other actions. It doesn't explicitly state when not to use it or name alternatives, but the timing guidance is strong enough to guide an 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It does convey that this is a read-only leaderboard view (no mutation implied), and it describes the content (top bettors with wallet, wagered, winnings). However, it doesn't disclose details like whether the list is paginated, how many entries are returned, or whether it reflects live/real-time data.

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

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

The description is a single, information-dense sentence that front-loads the tool's purpose (leaderboard of top bettors) and includes the key metrics. It's concise and structured well, though it could be slightly clearer with a period or restructured phrasing.

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, read-only leaderboard tool, the description is mostly complete. It tells the agent what data is shown (wallet, total wagered, winnings) and the context (Graviton betting game). However, it doesn't mention whether the leaderboard is live/real-time, how it's sorted, or any limits, which could matter for an agent deciding between this and top_traders.

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 the description doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description adequately explains what the tool returns without needing to compensate for any schema gaps.

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

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

The description clearly identifies the tool as a leaderboard for top bettors in the Graviton betting game, specifying the metrics shown (wallet, total wagered, winnings). It distinguishes itself from sibling tools like graviton_bet, graviton_state, and graviton_house_pool by focusing on the leaderboard aspect, though it doesn't explicitly name a sibling alternative.

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 this is a read-only leaderboard tool for viewing top bettors, which is clear enough for an agent to know when to call it. However, it doesn't explicitly state when to use this over alternatives like graviton_state or top_traders, nor does it mention any exclusions or prerequisites.

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 cost ('Costs 25 credits each'), the effects of each move (accelerate, knock rivals, hold position), and its role in gameplay. It does not mention failure conditions, reversibility, or response format, but the provided behavioral details are meaningful and beyond what the schema offers.

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 and front-loads the core action and move list. The final sentence adds useful context about gameplay sequence but could be trimmed. It is concise without unnecessary fluff, though slightly verbose in the last sentence.

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

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

There is no output schema and no annotations, so the description must cover essential context. It mentions cost, moves, and when to use, but omits prerequisites (e.g., having an active bet), potential errors, or what happens after use. For a tool that spends credits and affects a live round, more detail on state changes and failure modes would be beneficial.

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 fully explains the 'ability' parameter by enumerating and describing the three valid values. However, it provides no information about the 'wallet' parameter, which is essential for execution. The description adds value for one parameter but leaves the other undefined.

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 ('Use a move') and resource ('in the arena'), lists the three distinct moves (thrust, shove, brake) with parenthetical effects, and clarifies its role as the active playing mechanism. It clearly differentiates from siblings like graviton_bet or graviton_state by focusing on in-round ability 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?

The description provides clear context: 'This is how an agent actually plays rather than only watching: bet on a champion, then push it with moves while the round runs.' This implies the tool is used after betting and during a round, but it does not explicitly state when not to use it or mention alternatives. It gives a solid usage sequence without formal 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 provided, the description carries the burden of disclosing behavioral traits. It mentions that the tool returns treasury address, plans, and endpoints, which gives a sense of output structure. However, it does not clarify whether this is a purely informational read (likely) or if any on-chain interactions occur, nor does it describe side effects or prerequisites. It adds some value beyond the name but lacks depth.

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 with no waste. It front-loads the primary purpose and then lists the key return values. Every word earns its place, making it highly concise and well-structured.

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 is a how-to guide with no parameters and no output schema, the description covers the essential return values (treasury address, plans, endpoints) and hints at the flow (payment + activation). It doesn't specify the full format or step-by-step nature, but for a reference guide this is likely sufficient. The lack of an output schema means the description should do more, but it does provide a reasonable overview.

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

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

The tool has zero parameters, so the baseline for this dimension is 4. The description doesn't need to compensate for schema gaps since there are none. The description optionally adds nothing about parameters, which is appropriate; it doesn't mislead or create confusion around 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 clearly states the tool's purpose: providing instructions on hiring an autonomous agent on X1 with XNT, including the payment and activation flow. It is specific about the resource and what it returns (treasury address, plans, endpoints). While it doesn't explicitly contrast with sibling how-to tools like graviton_how_to_bet, it is unambiguous enough to distinguish itself.

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

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

The phrase 'How to actually hire an autonomous agent' implies use when a user or agent wants to hire, but it does not explicitly state when to use this tool versus alternatives (e.g., rental_agents, rental_plans, or other how-to guides). No exclusions or alternative routing are provided, leaving some ambiguity.

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 behavioral disclosure burden. 'List' clearly implies a read-only operation and the token standard scope is explicit, but it does not mention behavior around zero balances, pagination, ordering, or whether NFTs are excluded beyond the SPL/Token-2022 qualifier.

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

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

A single, front-loaded sentence that conveys the action, the specific token standard, and the address-space nuance. Every word earns its place with no redundancy.

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

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

For a simple one-parameter read tool with no output schema, the description covers the essential purpose, the exact token standards, and the chain/address context. Minor omissions like result ordering or zero-balance handling are acceptable given the tool's 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?

Schema coverage is 0%, so the description must compensate. It clarifies that 'wallet' refers to an X1/Solana address and notes the shared address space, which adds meaning beyond the bare schema. It does not specify expected address format or encoding, but the single parameter is self-explanatory.

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 ('List'), a precise resource ('SPL+Token-2022 token balances'), and a clear scope ('for a given X1/Solana wallet'). It clearly separates this from general wallet or token-lookup tools in the sibling list.

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 is implied: call this when you need the token-2022/SPL holdings of a specific wallet. However, it provides no explicit guidance about when not to use it or which sibling tool might be better for related needs like wallet profile or token lookup.

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 ranking logic (pool liquidity, then 24h volume, then holders), the honeypot risk shape, and the free cost. It doesn't detail output format or failure behavior, but the disclosed ranking and risk context go well beyond a minimal description.

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 and front-loaded with the core action, then provides concrete stats and ranking criteria. It's slightly long with the XNM example and the 'Free' note, but every sentence adds context about behavior or usage, so the length is justified.

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 tool with no output schema, the description covers the input semantics, the ranking behavior, the risk context, and the usage caveat. It doesn't specify the exact output shape, but the description's explanation of what the tool determines is sufficient for an agent to invoke 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 coverage is 100% and the single parameter 'symbol' is already described with an example. The description adds meaning by explaining that the symbol is a ticker that may map to multiple tokens, and that the tool will rank candidates — enriching the parameter's purpose beyond the schema's simple 'Ticker to check'.

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: given a ticker, find every token using that symbol and identify the most likely real one. It clearly distinguishes from siblings like token_lookup and whale_ticker by emphasizing ticker ambiguity and ranking by liquidity/volume/holders.

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

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

Explicitly says when to use this tool: when you have a ticker and need to resolve the real token, and warns to never resolve by ticker alone. It also names the alternative approach (resolve by mint address) and explains why this tool exists, giving clear context for selection.

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 must carry the behavioral burden. It explicitly discloses that build endpoints return unsigned transactions the agent must sign itself, which is a critical behavior for safe invocation. It also mentions the return value (cost config + feed). It doesn't cover rate limits or auth needs, but the signed-transaction disclosure is meaningful and credible.

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

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

Three short, front-loaded sentences with no filler. The purpose, return payload, and critical build behavior are all present in a compact format.

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 is incomplete relative to the schema. It claims a launch action but provides only an optional 'mint' parameter, which is for reading a single token's detail. An agent cannot tell how to initiate a launch from the given definition, so the tool is functionally incomplete. The lack of an output schema further means the agent must infer return shape from the partial description.

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 one optional 'mint' parameter with a complete description, so baseline is 3. The description adds extra meaning by clarifying that omitting mint returns the live cost config and recent launch feed, which goes slightly beyond the schema text. However, the claimed launch action has no corresponding parameter in the schema, so the description fails to explain how to paramere a launch.

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 'launch' with a clear resource ('a token on X1') and a read mode ('read what has been launched'). This distinguishes it from sibling tools like swap_build or token lookup: 'launch' is a distinct concept. However, it doesn't name an explicit alternative, so it falls just short of best-in-class clarity.

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

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

Very little guidance is given about when to use this tool instead of others. The note that build endpoints return unsigned transactions implies a separate signing step, but it does not state when to choose launchpad over e.g. swap_build or token_lookup, nor does it give explicit when-not-to-use criteria. The agent is left to infer 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 available, the description carries the transparency burden and does deliver a meaningful behavioral guarantee: results are explicitly classified as published, inferred, or a guess, so an agent knows not to treat all addresses as verified. It also implies crawling or site inspection, but it stops short of stating failure modes, rate limits, or side effects, 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?

Two short sentences front-load the primary action and then the output-labeling behavior. There is no filler, no repetition of schema fields, and the structure is easy for an agent to scan.

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 core workflow and the confidence classification are described, but the response shape is not specified and there is no output schema. It also leaves maxPagesPerSite unexplained and does not say what happens when no pattern or staff is found, so the description is adequate but not fully self-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?

The schema documents websites well, including the max-25 limit, and the description adds no parameter-specific detail on top of that. maxPagesPerSite is left with only its name, though the description's phrase 'staff found on its site' weakly hints at page-crawling scope.

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, non-trivial operation: infer a company's email-address pattern and apply it to staff found on the company website. It also states the distinguishing output, labeling each address as published, inferred, or a guess, which clearly separates it from generic contact-lookup 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?

The intended scenario is implied: provide one or more company websites and receive patterned, confidence-labeled staff email addresses. However, it never explicitly says when to prefer this over sibling tools like leads_find_contacts or leads_verify_domains, and it gives no exclusions or prerequisites.

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 and does meaningful work: it states the data source is OpenStreetMap open data, discloses free-tier limits and overage cost, and lists output fields (website, phone, address). It does not cover all edge behaviors, but it provides substantial transparency for a read-only 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?

Two tight sentences deliver the core purpose, output fields, data source, and pricing with no filler. The most important information is front-loaded.

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

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

Although there is no output schema, the description names the key returned fields. Combined with full parameter coverage in the schema and the explicit cost model, an agent has enough context to invoke the tool 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?

The input schema already documents all four parameters with descriptions, so the baseline is 3. The description reinforces that location is a town and categories are trades, but it adds little beyond the schema for parameter-specific 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 a specific verb and resource: finding businesses by town and trade, with examples of trades and the data returned. This clearly distinguishes it from sibling lead tools such as leads_find_contacts and leads_verify_domains.

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 clear usage context: search for businesses by location and trade category. It does not explicitly name alternatives or state when not to use it, but the intended use is unambiguous enough for an agent to select it appropriately.

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 transparency burden condensed into one sentence. It discloses the output fields, says junk addresses are filtered, and states the $15.00 per 1,000 companies cost, but it omits caveats like response format, failure modes, or data freshness.

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 dense sentence that efficiently conveys input, output, data quality, and pricing. Every element serves a purpose and nothing is redundant or padded.

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 communicates the core domain (website-to-contact enrichment), output fields, and cost, which is enough for basic tool selection. However, it does not explain response shape, potential empty results, or how the two optional parameters affect outcomes, leaving some uncertainty for an autonomous agent.

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

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

Schema description coverage is 100% for all three parameters, so the baseline is 3. The description adds context about pricing and output contents, but it does not explain how onlyWithEmail or maxPagesPerSite affect the behavior beyond what the schema already states.

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: given company websites, return named decision-makers with job titles, emails, phones, and LinkedIn. This is specific and immediately understandable. It does not explicitly contrast with sibling tools, so it stops short of a perfect score.

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

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

The phrase 'Give it company websites' makes the input requirement and primary use case clear: use this when you have a list of company websites and want contact details. However, it does not mention alternatives or exclusions relative to its siblings like leads_verify_domains or leads_find_businesses.

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 explicitly discloses the key behavior: it returns live conversion information and a payment address. Given the zero-parameter, informational nature of the tool, this is sufficient transparency about what happens on invocation.

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

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

Two sentences, front-loaded with purpose, with payment methods and return contents stated compactly. No wasted words or circular phrasing.

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-input informational pricing tool, the description fully covers when to use it interactively, what to expect (live conversion and payment address), and how payment works. There is no parameter, output schema, or safety concern that needs further explanation.

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 no parameters)SkipTo the schema already tells the agent everything about inputs. The description reinforces this by framing the tool as a direct informational query ('what the lead tools cost', 'returns live conversion').

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 immediately names the resource ('the lead tools') and the specific purpose ('what they cost and how to pay'), with explicit payment methods. This clearly distinguishes it from sibling lead tools like leads_find_businesses or leads_verify_domains, which are about discovery and enrichment rather than pricing/payment.

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 makes clear when to use the tool: when an agent needs lead-tool pricing or payment instructions. It doesn't explicitly contrast with sibling alternatives, but the pricing/payment angle is distinct enough across the sibling list. A minor improvement would be stating that this is a reference/pricing tool rather than a data-enrichment tool.

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

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

With no annotations, the description carries the full burden. It discloses the check type (MX/catch-all/provider) and the pricing ($0.20 per 1,000), which is valuable behavioral context. It does not describe the output shape, but this is a simple read-only validation 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?

Three sentences, each with a distinct job: what it checks, when to use it, and what it costs. No redundancy and the key purpose is front-loaded.

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

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

For a one-parameter, read-only verification tool, the description covers purpose, use case, input semantics, and cost. The only gap is the lack of an explicit output format, but this is minor given the simplicity of the operation.

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%: the single 'domains' parameter is already described as 'Domains or full email addresses (max 200).' The description only reinforces that it operates on a list, so it adds little 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 uses a specific verb ('Check') with a clear resource ('domains') and precise success criteria ('MX records, catch-all, provider'). This distinguishes it from sibling tools like leads_email_pattern or leads_find_contacts.

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 says when to use the tool: run it over a list before a campaign to avoid sending email to unreachable domains. It does not name alternatives or exclusions, so it stops short of a 5.

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

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

The description discloses a key behavioral trait: payment is on-chain and verified before ticket issuance, guaranteeing no ticket without payment. This adds meaningful context beyond the bare action, though it doesn't cover other behaviors like fees, 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?

The description is a single, compact sentence that front-loads the core action and then adds a crucial behavioral guarantee. Every word earns its place; no fluff or repetition.

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

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

For a zero-parameter tool with no output schema, the description covers the essential context: what the tool does and a key behavioral guarantee. It doesn't mention what the agent should do after buying (e.g., confirm to user), but that's minor given the tool's 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 the description doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description appropriately focuses on the tool's behavior rather than 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 states a specific verb ('buys lottery tickets') and resource ('with APEX'), which clearly identifies the tool's function. It doesn't explicitly distinguish from siblings like lottery_state, but the action-oriented phrasing makes the purpose clear enough.

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

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

The description implies usage context: an agent should use this when a user wants to buy a lottery ticket with APEX. However, it doesn't explicitly state when not to use it or mention alternatives like lottery_state for checking lottery status, leaving some 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses what information is returned (current draw, ticket price, pot, ticket count, draw time), which is useful. However, it does not state whether this is a read-only operation, whether it reflects live state, or whether any side effects occur. The description is adequate but not rich in behavioral context.

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

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

The description is a single sentence that front-loads the key information: current draw, ticket price, pot, ticket count, and draw time. It is concise and every phrase earns its place. It could be slightly more structured, but it is efficient and readable.

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

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

For a zero-parameter, no-output-schema tool, the description covers the main return values. However, it does not mention whether the data is live, cached, or how frequently it updates, nor does it clarify the currency or formatting of the pot and ticket price. Given the tool's simplicity, the description is mostly complete but leaves 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?

The tool has zero parameters, so the description need not explain parameter semantics. The baseline for zero-parameter tools is 4, and the description appropriately focuses on what the tool returns rather than parameters. No parameter information is missing.

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: it lists the current lottery draw, ticket price, pot, ticket count, and draw time. It is clear what the tool does, though it does not explicitly distinguish itself from sibling lottery tools like lottery_buy_how_to. The verb 'list' is implied rather than stated, but the resource and scope are clear.

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 this is a read-only status/info tool for the lottery, and the sibling lottery_buy_how_to suggests an alternative for buying. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The context is clear enough for an agent to infer usage, but explicit guidance 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, the description carries the behavioral burden and does well: it discloses that the transaction is unsigned, that the server never holds keys or signs, that XNT is wrapped internally, and that holding LP tokens raises the faucet cap. It does not cover failure or slippage behavior, so it is strong but not exhaustive.

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 concise sentences each earn their place: the action, the security model, and the prerequisite guidance. No wasted words, and the most important information is front-loaded.

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

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

Despite no output schema and no annotations, the description tells the agent what to pass, why, and what the outcome will be (an unsigned transaction to sign, LP tokens, raised cap). The only minor gap is the exact format of the returned unsigned transaction, but that is strongly implied by 'Build an UNSIGNED transaction.'

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 input schema already explains the wallet role, the wrapping of XNT, and that APEX is in whole tokens. The description adds little beyond reinforcing the ratio requirement, 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 first sentence states a clear verb ('Build') and resource ('UNSIGNED transaction that deposits XNT + APEX into the APEX/XNT pool and mints LP tokens'). It also distinguishes itself from read-only siblings like lp_position and from swap-building 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?

The description gives concrete preconditions: read current pool depth via lp_position or faucet_metrics first, and deposit roughly in pool ratio. It also points to lp_position for the faucet-cap ladder. It lacks explicit 'when not to use' exclusions relative to other build tools, so it is slightly 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?

No annotations are present, so the description carries the full behavioral burden, and "Read from chain" explicitly signals a read-only on-chain query — a meaningful disclosure of its non-destructive nature. It also lists the emitted data (balance, share, tier, faucet bonus), though it stops short of describing failure states like empty wallets or data freshness.

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 with no filler: the first delivered the resource and return fields, the second adds the read-only note. The most important information is front-loaded and every clause 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 query with a single rigid parameter and no output schema, the description names the four key return values, which gives a mostly workable picture. However, it leaves the wallet parameter's meaning ambiguous and does not address edge cases such as the tool being queried with a wallet holding no LP position, so it is 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 0% and the description never explains what "wallet" should be (the address? the agent's own wallet? a stored alias?) nor how the opening "Your" relates to the parameter. The description makes no effort to compensate for the bare schema: a low-coverage schema, so a clearly below-baseline score is warranted.

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 (liquidity standing on the APEX/XNT pool), an explicit read action, and the four data fields it returns (balance, pool share, tier, faucet cap bonus), so an agent knows exactly what this tool does at a glance. It does not explicitly distinguish itself from siblings like lp_add_build or holdings, so it stops just short of the full 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?

"Read from chain" implies the natural usage context (checking an account's LP standing), but the description gives no explicit when-to-use/when-not-to-use guidance and no alternative routing to siblings such as lp_add_build. The intended pick is inferable, but only by implication, leaving the score at baseline 3.

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 must carry the full burden. It discloses some return content but leaves a serious ambiguity: 'Buy and sell without waiting for a counterparty' implies transaction execution, yet the only parameter is an optional pool_id and no buy/sell parameters exist. It does not state whether the operation is read-only or mutating, nor any side effects or permissions.

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 at three sentences and front-loads the core concept and return value. Some phrasing ('arcade-style', 'without waiting for a counterparty') is promotional and not essential, but it remains readable.

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 partially explains the list response but not the pool-detail response structure. The biggest gap is the unresolved difference between returning market data and actually enabling buy/sell, which is critical for an agent deciding whether this tool can fulfill a trade request.

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

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

The single optional pool parameter is fully documented in the schema ('Optional pool_id for detail, price and recent trades'), so the description adds little beyond that baseline. It does tie the tool's output to pool details but does not explain parameter format or behavior.

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 tool as an NFT AMM marketplace and specifies a concrete result: 'Returns live pools with floor price, curve type and how many NFTs are in each.' It uses the bonding-curve concept to signal differentiation from fixed-listing marketplaces, though it does not name a sibling tool 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 or when-not-to-use guidance and no reference to sibling tools such as nft_trade_how_to or night_market. The 'Buy and sell without waiting for a counterparty' line implies the usage context, but alternatives and exclusions are 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?

With no annotations, the description carries the full burden of behavioral disclosure. It reveals a key behavior: the price moves along the curve with each trade, and instructs the agent to read the price first. However, it doesn't disclose whether the tool itself is read-only or mutating, or any other operational 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?

Two sentences with zero waste. The purpose is front-loaded, and the crucial behavioral warning about price movement is placed second. Every word earns its place.

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

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

For a how-to guide, the description is minimal. It provides the key action (read price first) but doesn't outline the full trading process or mention any prerequisites or outcomes. Given there are no parameters or output schema, it's acceptable but not thorough.

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 per the baseline rule this dimension is scored 4. There is no schema detail to compensate for, and the description's mention of price behavior is not parameter-related.

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

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

The description clearly states it's a how-to guide for buying or selling NFTs on the bonding-curve marketplace, specifying the resource and action. It doesn't explicitly contrast with sibling how-to tools like commodity_how_to_trade, but the resource is specific enough to distinguish it.

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

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

The description implies when to use it (when trading NFTs on the bonding-curve marketplace) but does not provide explicit alternatives or exclusions. Siblings include many other how-to guides, but no guidance is given on when to choose this one over them.

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 discloses the two-phase bid/reveal behavior, the requirement to check phase, and the consequence of an unrevealed bid. It does not mention whether bids are refundable or if there is a fee, but the core behavioral contract is well 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?

Three sentences, each carrying essential information: what the tool is, how the mechanism works, and the critical phase-check warning. No filler or repetition.

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

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

For a parameterless tool with no output schema, the description explains the auction flow and the key constraint. It could add what the agent should do after checking the phase, but the essential context for correct invocation 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?

The tool has zero parameters, so the description need not explain parameter details. It still adds context about what the agent should know before interacting, which is appropriate 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 identifies the tool as a weekly sealed-bid auction in Citizens City, with a specific bid-commit-then-reveal mechanism. It distinguishes itself from other auction-like tools by naming the exact game and phase structure.

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 instructs the agent to check the phase before doing anything, and states that bids are only accepted while open and unrevealed bids cannot win. This gives clear when-to-use and when-not-to-act 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 behavioral burden and does disclose meaningful traits: these games are pure on-chain, have no server in the middle, require the agent to build and sign the instruction, and are immutable. One gap is that it does not clarify the exact behavior of the tool call itself, such as returning a list or a descriptive guide, but the disclosed trust and execution model 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?

The description is short and front-loaded with the main topic, and each sentence adds a meaningful property: pure on-chain, no server, self-signed instructions, immutability, and verification. It slightly loses structural clarity by leading with a noun phrase rather than an explicit purpose statement, but there is no wasted content.

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?

Although the tool is simple with no parameters and no annotation burden, there is no output schema and the description does not say what the agent will receive after calling it—a list of games, static educational text, or instructions. The trust details are helpful, but this incomplete return expectation leaves an agent uncertain about how to consume the tool's result.

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 and schema description coverage is 100%, so there are no parametric semantics missing. The description does not need to compensate for parameter documentation, and it avoids introducing any confusing parameter-like expectations.

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 as games on X1 that are pure on-chain programs and distinguishes them from server-mediated games, but it never states the tool's actual action (e.g., 'lists', 'shows', 'gets'). An agent can infer the purpose from the name and content, but the lack of a clear verb makes it only minimally viable.

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 no guidance about when to call this tool versus alternatives such as games_index or individual game tools. It mentions important properties like immutability and no server in the middle, but it does not specify the use case, preconditions, or which sibling to choose instead.

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 mentions that fills settle between wallets and the desk only tracks state, which gives some behavioral context. However, it does not disclose side effects, authentication needs, or clearly state whether the tool is strictly read-only. With no annotations provided, the description carries the full burden and falls short.

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 purpose, and avoids redundancy. It is concise and well-structured, though it could be clearer about the parameter and action scope.

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 an undocumented parameter, the description is incomplete. It provides high-level context about the OTC desk but lacks critical details like parameter purpose, return format, and a definitive statement of the tool's actions.

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

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

The input schema has one optional parameter, orderId, with no description, and the tool description does not mention it at all. Since schema description coverage is 0%, the description completely fails to compensate, leaving the agent with no guidance on what to pass.

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

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

The description clearly states it is a P2P OTC desk for large sizes and that it reads the live order book and stats. It distinguishes itself from other trading tools by emphasizing P2P and pool-moving size, but it does not explicitly state whether the tool is read-only or also initiates trades.

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 for large trades that would move a pool, but it does not explicitly state when to use this tool versus alternatives. It never names a sibling tool or provides conditions for selection, leaving the agent to infer the appropriate 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?

Since no annotations are provided, the description carries the burden. It clearly states that the tool returns retirement details, not live markets, which is a behavioral disclosure. However, it does not explain what 'retirement details' include (e.g., closure date, reasons, refunds?), but the core behavior of returning non-live data is explicit.

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 very brief but effective. It front-loads the retirement status and the closure date interactively. However, it could be slightly clearer by stating that it returns retirement details and not live data in one sentence. But overall it is concise without fluff.

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 tool is simple (0 params, no output schema, no siblings that are clearly related). It conveys the core fact needed: markets are closed AMAund, but details about what exactly the tool returns (retirement details) are not elaborated. For an agent, it may be enough, but it could state the kind of information contained (e.g., closure date, refund process).

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)Skip, so the schema covers everything (100% coverage). The description does not need to explain parameter semantics since there are none. Thus a baseline of 4 is appropriate because there is no parameter burden.

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 that the tool returns retirement details and that the markets are closedable, but the actual function's purpose is clear enough: it provides info about the retirement. However, it does not name a specific verb like 'get' or 'retrieve', so it's slightly vague. It distinguishes from siblings implicitly by saying it is retired, but not as strongly as a clear verb-resource pairing.

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

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

There is no guidance on when to use this tool. It says that X1 Prophet markets are closed, but does not mention any alternatives or conditions under which an agent should call this vs a sibling. For instance, it could say 'Use to check retirement details; no live data is available.' There's no alternate tool referenced, so the usage context is incomplete.

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 only states the core function, which is a read operation, but does not disclose any additional traits such as rate limits, error behavior, or output format. It is not misleading, but it provides minimal behavioral context beyond the obvious purpose.

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 concise sentence with no wasted words. It is front-loaded with the purpose and contains no extraneous information. This is ideal for a simple tool and earns full marks for conciseness.

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

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

Given the simplicity of the tool (two parameters, no output schema), the description is minimal but not entirely inadequate. It tells the agent what the tool does but does not explain the return format or the effect of the 'limit' parameter. For a tool with no output schema, more detail on the expected result would be helpful, so a 3 reflects this 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?

The schema description coverage is 0%, so the description must compensate. It explains that the primary parameter 'mint' refers to a token mint, which adds meaning, but it says nothing about 'limit'. Since only one of two parameters gets any contextual explanation, the description only partially compensates for the lack of schema descriptions, warranting a low 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 verb ('Recent on-chain trades') and the resource ('token mint'), so an agent knows what the tool does. However, it does not differentiate it from sibling tools like top_traders or whale_ticker, which also deal with trade data. The purpose is clear but lacks sibling distinction, so a 4 is appropriate.

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 no guidance on when to use this tool versus alternatives. It does not mention scenarios, exclusions, or refer to any sibling tools. An agent has to infer that this is for recent trades on a specific mint, but there is no explicit context on when it is preferred over other trade-related tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the reward is an ongoing SHARE, not a signup bonus, describes payment from the faucet's daily budget, and mentions the cap ensuring it never exceeds a fixed slice. This is substantial, though it omits potential side effects like code uniqueness or irreversibility, which a cautious agent might need.

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 dense paragraph that front-loads the functional usage before explaining the reward model. While thorough, the reward explanation is lengthy and could be tightened without losing meaning. Every sentence adds value, but it is slightly verbose relative to the tool's simplicity.

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 (two modes, reward mechanics) and the absence of an output schema, the description fully covers what an agent needs: how to retrieve info, how to claim, what the reward structure is, and the cap. No critical operational detail 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 schema already documents both parameters (wallet and code, with type and length constraints, coverage 100%). The description adds critical semantic value by clarifying the conditional relationship: wallet alone yields info, wallet+code claims a code. This goes beyond the schema's individual descriptions and is essential for correct usage.

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 handles the referral programme, specifying two distinct uses: pass wallet to view code/count/earnings, or pass wallet+code to claim a code. This is a specific verb-resource pairing and distinguishes itself from any potential alternatives by focusing on referral mechanics 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?

Explicit usage scenarios are given: 'Pass a wallet to see that wallet's code, referral count and earnings; pass wallet AND code to claim a code.' This leaves no ambiguity about when to invoke the tool and how parameters should be provided. Though no alternatives are mentioned, the conditions are clear enough to prevent misuse.

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 clearly states this tool only shows availability (free counts) and does not hire. The extra line about hired agents doing real on-chain work and paid wages sets expectations without overpromising. No side effects are implied, and this is a read-only listing.

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 with no fluff. The essential info (availability by role) is front-loaded, and the last sentence provides useful context about hired agents. Slightly redundant for a pure listing tool, but overall compact.

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, zero-param listing tool with no output schema, the description is sufficient: it tells the agent what the tool returns (free counts per role) and provides background context. It lacks a note on exact output format, but that's minor for a list lookup.

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?

Tool has zero parameters, so parameter description coverage is automatically 100%. Baseline for 0 params is 4; the description adds nothing about parameters because none exist. Nothing to clarify.

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

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

Description clearly states the resource (agents available in Citizens City) and the specific output (how many are free per role). It names concrete roles and leaves no ambiguity about the tool's function, and it is easily distinguished from sibling tools like agent_radio or hire_agent_how_to.

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 this is used to check availability before hiring but doesn't explicitly say 'use this when...' or point to alternatives like 'rental_plans'. It gives useful context about hired agents but lacks direct guidance or exclusions compared to other rental-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates the nature of the content (pricing plans) and includes a specific detail (0.5 XNT day pass), but it does not describe output format, whether prices are live/static, or any side effects. This is adequate for a simple pricing lookup but not richly 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 dense sentences; the first states the core purpose and plan options, the second adds a useful, concrete pricing detail. There is 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 zero-parameter, simple pricing-info tool, the description is largely sufficient: it names the domain, the plan durations, and the cheapest option. It does not enumerate every price or return shape, but it gives an agent enough context to expect plan data, and no output schema exists to cover that 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?

The tool has zero parameters and the input schema is a bare object, so there is nothing for the description to explain. Per the baseline for 0-parameter tools, the description need not add parameter-specific meaning.

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 ('hire an autonomous agent on X1') and the kind of information provided ('Pricing... day pass, week, or month'). It is specific enough to be understood, though it does not explicitly contrast with sibling tools like rental_agents or hire_agent_how_to, so it stops short of full 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?

There is no guidance about when to use this tool versus alternatives such as rental_agents, hire_agent_how_to, or rental_work_proof. The description implies the purpose (getting pricing plans) but does not state conditions for selection or exclude other tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explains that entries carry real X1 transaction signatures and can be audited on the explorer, which is useful. However, it does not disclose pagination behavior, ordering, or whether the ledger is append-only, which would be relevant for an agent deciding how to use the results.

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 waste. The core value proposition (verifiable, auditable) is front-loaded, and the optional filter is mentioned at the end. Every word earns its place.

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

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

For a simple list tool with two optional parameters and no output schema, the description is nearly complete. It explains the unique value (X1 signatures, auditability) and the filter option. A minor gap is the lack of explicit mention of default ordering or time range, but the tool's simplicity and schema coverage make this a minor omission.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (limit and renter). The description adds the meaning of the renter filter ('filter to one renter') but does not add syntax or format details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a verifiable proof-of-work ledger for hired agents, with a specific verb ('audited') and resource ('proof-of-work ledger'). It distinguishes itself from generic list tools by emphasizing the X1 transaction signature and auditability, which sets it apart from siblings like recent_trades or firehose.

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 context: it is for auditing hired-agent labor, and the optional renter filter suggests a use case of narrowing to a specific wallet. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to select it appropriately 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 of behavioral disclosure. It adds useful context about the sensitive nature of the content and that some cards include wallets for direct support, which goes beyond the tool name. However, it never explicitly states that the tool is a read-only listing or what happens when invoked.

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 and well-organized in three short sentences. Every sentence adds meaningful context about the people, the nature of the cards, and the wallet capability, though it reads more like evocative prose than a structured tool specification.

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 tool, the description conveys the core subject matter effectively but omits an explicit statement of what the tool returns or does. An agent would need to infer that calling safetynet_cards produces a list of these cards, which is a meaningful 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?

The tool has zero parameters, and the schema is an empty object, so there are no parameter semantics to document. The baseline of 4 applies here; the description reasonably covers the purpose of the data instead.

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: cards representing real people in the APEX community who have asked for help. It distinguishes itself from sibling safetynet_how_to_help by describing the data content rather than instructions, though it lacks an explicit action verb like 'list' or 'view'.

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, and no mention of safetynet_how_to_help or any other sibling. The usage is only implied by the content description, which is not enough for an agent to confidently select this tool over similar list/info tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a key safety trait ('This site never holds the money') and describes the process of sending value and recording transactions. However, it does not explain what the tool actually does (e.g., returns step-by-step instructions), any side effects, or the response format. This partial transparency warrants a 3.

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 concise sentences that front-load the topic and provide a key safety note. There is no filler or redundant wording. It is appropriately sized for an instructional tool and structured efficiently.

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

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

This is a simple tool with one parameter, but the description is incomplete. It does not explain what cardId is used for, what the tool returns (e.g., text instructions), or any prerequisites. Since there is no output schema, the description should clarify the output. The description focuses on the domain but not the tool's operational behavior, leaving significant gaps for an agent.

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 one parameter, cardId, with no description, and schema description coverage is 0%. The description does not mention cardId at all, so it adds no meaning to the parameter. An agent would have no idea what to pass or why. The description completely fails to compensate for the missing schema 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?

The description clearly states the tool's purpose: providing guidance on how to help someone on SafetyNet by sending value directly and recording the transaction. It distinguishes itself from other how-to tools by specifying the SafetyNet context, and from safetynet_cards which likely deals with card management. However, it doesn't explicitly state that it returns instructions or a guide, so the purpose is clear but not fully explicit.

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 on when to use this tool versus alternatives. It does not mention when not to use it, nor does it compare to sibling tools like safetynet_cards or other how-to tools. The description implies it is for understanding how to help, but lacks explicit usage context 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?

Since no annotations are provided, the description carries the full burden. It discloses that the tool returns catalogue, live stats, and a full order ledger, and that every purchase is public. This gives some behavioral context but does not say if the tool is read-only, whether there are any rate limits, or how results are structured. It does not contradict annotations (none exist), but for a read-only market listing, these gaps are minor.

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, dense sentence that front-loads the core purpose (Sentinel Market) and immediately states what it returns. It has no filler, is easy to scan, and every phrase adds value. The structure is optimal for a 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?

Given the tool has no parameters and no output schema, the description sufficiently covers what an agent needs to know: it returns catalogue, stats, and a public ledger. It doesn't explain the exact format of those results, but without an output schema, that's not strictly required. The description is complete for a simple listing tool of moderate complexity.

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 explain. The schema coverage is effectively 100% (empty object), and the description does not need to add parameter details. The baseline for 0 parameters is 4, and since nothing is omitted, it appropriately scores 4.

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

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

The description clearly states the tool's purpose: it is a market for machine-readable data services sold agent-to-agent, returning a catalogue, live stats, and a full order ledger. It uses specific verbs and a distinct domain (agent-to-agent data services), which differentiates it from generic market tools like commodity_markets or service_market. It is not a tautology, though it does not explicitly contrast with 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?

The description provides no guidance on when to use this tool versus alternative markets (e.g., commodity_markets, service_market). It doesn't state any preconditions or context that would help an agent decide to pick sentinel_market over its siblings. The description implies it for data services, but no explicit when-to-use or exclusions are given.

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 behavioral disclosure burden. It describes the return behavior ('live service list and stats') and implies a read-only query through 'returns'. It does not mention authentication or rate limits, but for a zero-parameter public list tool this is sufficient.

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: the first establishes the domain and features, the second states the output. No filler or redundant 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 simple zero-parameter tool, the description provides enough context to understand what it returns (live service list and stats) and the marketplace domain. 'Stats' remains somewhat underspecified, but no output schema is present, and the tool is still directly actionable.

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

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

The input schema has zero parameters and 100% schema coverage, so the baseline is 4. The description has nothing to add about parameters, and none are needed.

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 live service list and stats' for the Citizens Marketplace, and specifies the domain (agents selling services for XNT). It is clear, but it does not explicitly differentiate from sibling marketplaces like sentinel_market or nft_marketplace.

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 — 'agents selling services to other agents for XNT' — and states the produced output, so an agent knows to invoke it when it needs the live service list and stats. It does not explicitly name alternatives or exclusions, so it misses 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 behavioral burden and it delivers useful context: it explains that posts with a tx_signature are permanent on X1 while others remain only in the site database. It does not discuss pagination or default sort order, but for a read-only feed it provides meaningful transparency beyond a simple 'read' statement.

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 concise sentences with no filler. Each sentence contributes: it names the resource, states the returned data, and adds an important permanence nuance. It is front-loaded with the core purpose.

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

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

Although the tool is simple with one optional parameter, the description does not document the sort parameter at all. There is no output schema and no annotation context, so an agent cannot confidently invoke the tool with a non-default sort value or know what the response shape will be. The persistence caveat is helpful but not sufficient to compensate for the missing parameter documentation.

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?