SolMachina

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

With no annotations provided, the description carries the full behavioral burden, and it does well: it discloses the conservative stance ('unknown' over guessing), per-mint result or explicit error handling, and the non-financial-advice disclaimer. It does not detail return format, rate limits, or behavior on malformed input beyond 'explicit error,' but the core behavioral traits are genuinely disclosed.

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

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

The core purpose is front-loaded in the first clause, and the description packs purpose, scope, behavioral stance, disclaimer, and input requirement into a compact form. The 'Requires ?mints=...' fragment is mildly redundant with the schema, but every other sentence earns its place. Efficient and well ordered.

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 annotations and no output schema, the description covers purpose, batch scope, per-mint error semantics, the risk dimensions examined, and the input requirement. It gives a reasonable picture of expected results via 'each mint returns its own result.' It could add output structure or timeout behavior for 10 mints, but for a batch scan tool the coverage is strong.

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 the comma-separated format, 10-mint cap, duplicate removal, and example. The description's 'Requires ?mints=...' line reinforces the format but adds little beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a specific verb ('scan'), resource ('SPL token mints'), scope ('up to 10'), and mode ('batch... in ONE call'). The batch framing clearly differentiates it from the singular sibling solmachina_token_risk, and the parenthetical enumerates the specific risk dimensions checked. Purpose is unambiguous and distinct.

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?

Positions the tool as 'a portfolio/watchlist bundle over the token-risk engine,' which clearly implies batch use cases over the single-token alternative. It also discloses per-mint independent results. However, it does not explicitly name the alternative (solmachina_token_risk) or state an exclusion condition ('use single-token when you have one mint'), so some inference is 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 full burden. It discloses that the operation is a discovery/read action and that it is free, which adds useful cost context. However, it does not describe return format, size, or whether the catalog is cached/stale, leaving behavioral details thin. There is no contradiction with annotations since none 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?

The description is a single tight sentence with zero waste. The main action and resource are front-loaded, the returned fields follow in parentheses, and 'FREE' is appended as a terse, useful qualifier. Every element 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 zero-parameter discovery tool with no output schema, the description is largely complete: it names the resource and lists every data element an agent can expect to receive. Minor gaps like pagination or format details are not material for a simple catalog fetch, though they would have pushed it to a 5.

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

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

With 0 parameters and 100% (vacuous) schema coverage, the baseline is 4. The description adds real value by enumerating what the response will contain (endpoints, USDC prices, category, network, payTo), effectively serving as the return contract in place of an output 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 ('Discover') and names a concrete resource ('x402 catalog') along with its exact contents (endpoints, USDC prices, category, network, payTo). This clearly distinguishes it from all 25 siblings, none of which mention a catalog. 'Discover' is slightly softer than a verb like 'List' or 'Get', 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?

There is no guidance on when to use this tool versus any alternative. None of the sibling tools are referenced, no exclusions are stated, and no conditions for selection are given. The 'FREE' note is about cost, not usage context. The agent is left to infer this is a read-only catalog 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?

With no annotations, the description carries the behavioral disclosure burden and does a strong job: it discloses that the tool returns REVIEW/unknown rather than guessing, that it is a transparent risk gate, that it does not execute actions, and that it supports per-transaction binding via tx. It adds meaningful non-obvious behavioral context beyond the schema, though it does not address externalities like rate limits or auth requirements.

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

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

The description is long but appropriately dense; it front-loads the core purpose and output shape before adding caveats. Minor redundancy exists (e.g., restating required and optional parameters that are already in the schema), but no fluff paragraphs or tangential information are included.

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 12 parameters and no output schema, the description gives a good high-level contract: output components, the fail-closed risk gate stance, and the 'not financial advice' limitation. It is complete enough for an agent to call it with the required mint and understand what the return fact family will be, though it could have added more explicit guidance on how to pick between policy presets or when to include tx=.

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

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

Input schema description coverage is 100%, so the schema itself carries the parameter meaning. The description adds only a high-level grouping of parameters (e.g., named firewall presets, 'fail-closed' thresholds) and repeats some schema details, but it does not meaningfully deepen the understanding that the schema already provides for the 12 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, compound function: it composes on-chain risk signals into a single EXECUTE/REVIEW/REJECT verdict plus SMRI, confidence, and evidence. It also clearly frames itself as a decision layer rather than a raw data or profit tool, though it does not explicitly contrast itself with sibling tools like solmachina_smri or solmachina_pretrade.

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 it is 'the decision layer for autonomous agents' and gives prerequisites (?mint=, optional parameters), which implies the usage setting. However, it does not tell an agent when to choose this over solmachina_smri, solmachina_token_risk, or solmachina_pretrade, and gives no explicit when-not-to-use guidance, only negative disclaimers about financial advice.

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

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

With no annotations, the description takes on the burden. It discloses that the result is a quote, not an execution guarantee, and not financial advice. It also mentions the freshness slot and price-impact thresholds, giving insight into output characteristics. No side effects are claimed, which is reasonable for a read-only quote.

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 information-dense but not excessive. It separates the main purpose, the disclaimer, and the required parameters. The repetition of 'Requires' is slightly redundant with the schema but does not harm readability.

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

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

For a quote tool with 4 parameters and no output schema, the description covers essential context: what it computes, the non-guarantee nature, and required inputs. It does not specify exact output structure, but that is expected of a quote tool and not a gap.

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

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

Schema description coverage is 100%, so every parameter is well defined. The description reinforces that amount is in base units and explicitly shows the required parameter names in the 'Requires' clause, adding practical clarity beyond the schema.

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

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

The description clearly states the tool returns a live aggregated Solana swap quote from Jupiter, enumerating key outputs (best-route, price impact, min-received, route path, USD value). It explicitly distinguishes a quote from execution, making the purpose unambiguous.

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

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

The description provides strong context on when to use it: it is a quoting tool, not an execution guarantee, and lists required parameters in a 'Requires' clause. It does not explicitly name alternative tools for comparison, but the 'NOT execution' warning effectively guides appropriate use.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It states the tool returns live epoch info and an ETA, but it does not disclose side effects, freshness guarantees, or output structure. Some behavior is described, but not comprehensively.

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 concise and front-loaded with the core purpose. The phrasing is a bit awkward in 'dual measured slot-rates labeled', but it remains compact 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?

The tool is relatively simple with one optional parameter and no output schema. The description gives a basic sense of the output—epoch info, ETA, and dual labeled rates—but lacks precise response details or edge-case behavior. It is adequate 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 schema already fully describes the rate parameter and its allowed values. The description adds little beyond the schema, only slightly clarifying that the chosen rate drives the ETA. This meets the baseline for schema-covered parameters.

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

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

The description clearly identifies the tool as providing live epoch information and an ETA to epoch end, with a specific focus on dual measured slot-rates. It lacks an explicit verb like 'get' or 'retrieve', but the purpose is unambiguous.

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

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

The description explains the optional rate parameter but provides no guidance on when to use this tool versus any sibling tools, nor when to choose 'primary', 'alt', or 'both' rates. Usage context is largely left to inference.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a useful behavioral trait: 'FREE' signals the tool itself requires no payment, which is meaningful for a payment-guide tool. However, it does not describe the response format, whether the explanation is textual or structured, or any limits on the endpoint parameter's effect on the answer.

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 that front-loads the core purpose ('Explain the x402 402->sign->retry flow') before the motivation and the FREE note. It is appropriately terse with no filler. The trailing 'FREE.' is cryptic but earns its place as a behavioral disclosure; slightly more context would push it to a 5.

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

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

Given the low complexity (0 required params, no annotations, no output schema), the description is reasonably complete for stating intent. However, the role of the optional 'endpoint' parameter in shaping the explanation is not addressed in the description, and the return format of the explanation is unspecified, which an agent would need to interpret the result 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% — the 'endpoint' parameter already has a clear description ('optional endpoint path, e.g. /v1/decision'). The main description adds nothing about the parameter's semantics beyond the schema, so the baseline of 3 applies. No additional syntax or behavioral meaning is supplied for the optional endpoint.

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: 'Explain the x402 402->sign->retry flow.' This is a how-to/guide tool, clearly distinct from its 24 data-query siblings (decision, simulate, dex_quote, etc.). The 'FREE' note adds a distinguishing behavioral marker. Slightly held back because it doesn't name a sibling or contrast explicitly, though the nature makes differentiation obvious.

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 'so an agent can pay a paid endpoint with its own wallet' implies usage when an agent hits a 402/payment-required response and needs guidance on paying. This is an implied trigger condition rather than an explicit one. It doesn't state when not to use it or name alternatives among siblings, leaving the routing decision mostly to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose 'trimmed JSON' and that limit caps returns, which is useful, but it does not clarify what 'trimmed' means, whether results are paginated, data freshness, or error behavior. For a read tool the bar is lower, yet the vague 'trimmed' leaves meaningful ambiguity.

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 one short efficient sentence plus a half-sentence on the parameter, front-loaded with the resource name. There is no wasted text, though it could have used the brevity to add one clarifying detail about the trimmed 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?

For a low-complexity tool (one optional parameter, no output schema, no nested objects) the description is mostly adequate: it names the resource and the limit behavior. However, the 'trimmed JSON' phrasing is vague and, without an output schema or annotations, the agent is left guessing about the exact return shape and how to paginate.

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 limit parameter is fully documented in the schema (integer, 1-100, default 100). The description's 'Optional ?limit caps how many markets are returned' slightly reinforces the schema's effect but adds no new semantic detail. Baseline 3 is appropriate given full 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 identifies a specific resource (Kamino mainnet markets) and action (list/return), plus a format hint (trimmed JSON). It is clear enough for an agent to know this fetches the market list, and no sibling tool is obviously a close substitute, so differentiation is not a problem.

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 alternatives, no exclusions, and no context about typical call scenarios (e.g., 'use when you need the full market list' vs. other market tools like new_pairs or trending_tokens). The when-to-use decision is left entirely to the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly states 'Factual observation only, NOT a recommendation. NOT financial advice,' which clearly sets expectations about the tool's output being informational. It also discloses the risk profile of new pools. While it does not explicitly say the tool is read-only, 'observation' implies no side effects. This is adequate for a simple listing 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 concise and well-organized, front-loading the core purpose and returning fields, then adding necessary risk warnings and usage hints. Every sentence contributes value; there is no fluff. It is slightly longer than strictly necessary due to the disclaimers, but those are relevant for user safety.

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 tool with one optional parameter and no output schema, the description covers what the tool returns, the source (GeckoTerminal), the risk warning, and the recommended follow-up action (token-risk). It is complete enough for an agent to know what to expect and how to invoke it. The only minor gap is not describing the exact output structure, but the field list suffices.

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%, fully documenting the limit parameter with range and default. The description repeats this ('Optional ?limit (1-20, default 15)') but adds no new meaning beyond the schema. Per the rubric, a baseline of 3 applies when schema coverage is high, so this score 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 lists the newest Solana liquidity pools from GeckoTerminal and enumerates the fields returned (name, base mint, creation time, age, liquidity, 24h volume, price change). It is specific and unambiguous, though it does not explicitly differentiate from sibling tools like solmachina_trending_tokens, which might also return pool-like data. Still, 'newest pools' is distinct enough.

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

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

The description provides usage context by warning that new pools are unvetted and high-risk and recommends pairing each mint with /v1/token-risk before acting. It also mentions the optional limit parameter. However, it does not explicitly state when to use this tool versus alternatives (e.g., when to choose this over trending_tokens or token_risk). The guidance is implied rather than explicit, so it falls short of a full 'when to use' specification.

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 states 'Factual snapshot,' which implies a read-only operation without side effects, and includes disclaimers about not being a recommendation. However, it does not explicitly declare that no transactions or modifications will occur, leaving some ambiguity.

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-structured, with a clear first sentence stating the core function, a note about the floor price meaning, and a disclaimer. No redundant information is present, though the disclaimer could be considered slightly extra but is relevant 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?

The description covers the data returned, clarifies a key metric (floor price), and states the required parameter. It does not specify the output format, but since no output schema exists, this is acceptable. The context is sufficient for an agent to understand what the tool does and what input is needed.

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

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

The schema fully describes the single 'symbol' parameter with type and example, achieving 100% schema description coverage. The tool description merely repeats the requirement without adding extra semantic detail, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: it provides a snapshot of a Solana NFT collection from Magic Eden, listing specific data points (floor price, listed count, 24h average price, 7-day volume). This is a specific verb (snapshot) and resource (NFT collection), and it distinguishes itself from sibling tools by focusing on NFT collections.

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 that a symbol parameter is required and explains the meaning of the floor price, but it does not explicitly state when to use this tool versus alternatives. There is no reference to other tools for comparison or conditions under which this tool should be chosen, leaving usage guidance mostly implicit.

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 critical behavioral traits: verdict-free output, explicit errors for partial sub-analyses rather than silence, and 'not financial advice'. It also notes the required query parameter. It does not explicitly state read-only or side-effect-free, but for a data-analysis sweep this is reasonably implied; the disclosed traits are valuable and non-obvious.

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, front-loaded with the main purpose, and each clause adds information (components, verdict-free, error handling, not advice, requirement). It is somewhat long but justified given the tool's complexity; no wasted words. A 4 reflects good structure without being overly terse.

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

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

For a tool with no output schema and no annotations, the description explains what the tool returns (checklist, verdict-free), how it handles partial results (explicit errors), and the required parameter. It does not mention pagination or potential limits, but these are not critical for a sweep tool. Overall it covers the key usage aspects well, meriting a 4.

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

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

Schema coverage is 100% for the single 'mint' parameter, which already includes an example. The description adds little beyond the schema, merely restating that the sweep requires a mint address. With full schema coverage, the baseline of 3 is appropriate; the description doesn't provide extra semantic detail beyond what the schema offers.

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

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

The description opens with a specific verb-resource pair ('PRE-TRADE SWEEP for a token') and enumerates exactly what the bundle contains: token-intel (risk + digest + holder classification), a wallet-activity profile of the largest holder, and priority-fee bands. This clearly distinguishes it from the sibling tools like solmachina_token_risk or solmachina_token_holders, which individually cover only parts of this sweep.

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

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

The description implies a one-call alternative to multiple sibling calls, but does not explicitly state when to prefer this over separate tools or name exclusions. It gives strong contextual cues (pre-trade, one-call) but lacks an explicit when-not or alternative guidance, so it earns a 4 rather than 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 transparency burden. It discloses output units, observed data, and non-predictive nature, but does not mention read-only behavior, failure modes, or data source.

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 convey the core output, units, optional filter, and key limitation without extraneous detail.

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

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

Sufficient context is provided for a call: output shape, units, optional filter, and non-guarantee caveat. Slightly more detail about interpretation of the bands could improve completeness given no output schema.

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 only parameter accounts is already fully described in the schema; the prose adds little beyond restating that it narrows the sample to write-locked transactions.

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

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

Clearly states it returns observed priority-fee distribution with percentiles and suggested bands in micro-lamports per compute unit, and distinguishes this from prediction by emphasizing observed 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?

Implicitly indicates use for recent historical fee context and optional account filtering, but does not explicitly compare with sibling tools like solmachina_tipfloor or state when this tool should be preferred.

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. It explicitly states the tool is 'FREE' and for 'inspect before paying', indicating no cost and non-destructive behavior. This provides sufficient transparency for the user's expectations.

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, using a single sentence to convey purpose, cost, and value. Every word adds meaning, and it is well-structured 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?

For a preview tool, the description provides sufficient context: what it previews (response shape/example, inputs, price) and why to use it (inspect before paying). Slightly more detail on the response format could improve completeness, but it is not essential.

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 'endpoint' parameter is described with a concrete example ('/v1/token-holders'), making the expected format clear. Although the description is minimal, the schema's 100% coverage and the example suffice for a single string parameter.

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

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

The description clearly states that this tool provides a free preview of any endpoint, showing response shape/example, inputs, and price. It effectively differentiates from sibling tools by being a generic preview tool rather than a specific data endpoint.

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 'inspect before paying' implies that this tool should be used to evaluate an endpoint before committing to a paid call. While it doesn't explicitly name alternative tools, the guidance is clear and contextually appropriate given the list of paid sibling endpoints.

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 and does a solid job: it explains the live multi-RPC reading, the peristence via on-disk series, the measurement-based nature, and the optional output size. It does not explicitly state read-only behavior, but no mutating action is implied.

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 one dense but informative sentence, with the key purpose front-loaded and the optional parameter mentioned at the end. It is concise, though the parentheticals make it slightly less clean than ideal.

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

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

Given the simple optional parameter and no output schema, the description gives enough context: it identifies what is measured, what is returned conceptually, and the optional n effect. It could be more explicit about output formatting, but it is adequate for the low 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 only parameter n is fully described in the schema, and the description repeats that it is optional and controls return count. No additional semantic meaning beyond the schema is provided, so this is at the baseline.

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

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

The description clearly states a specific purpose: providing a measured Solana epoch-transition checkpoint series derived from live getEpochInfo data, yielding slot-rate, ETA, and last epoch-transition detection. It is distinct enough from related tools, though it does not explicitly name sibling alternatives.

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

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

The phrasing implies use when a measured, not modeled, epoch-transition analysis is needed, and it mentions the optional n parameter. However, it does not explicitly state when to choose this tool over sibling tools or provide exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden, and it delivers: explicitly discloses that it NEVER signs or sends, that simulation is NOT a guarantee of the real on-chain outcome, and adds a non-financial-advice caveat. For a simulation tool these are the critical behavioral traits an agent must know before calling 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 a single front-loaded paragraph that leads with purpose and safety traits. It is efficient overall, though the 'NOT financial advice' clause reads as boilerplate and the parenthetical adds minor noise. Nothing critical is buried.

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 and no annotations, the description is remarkably complete: it covers purpose, input requirement, safety behavior (no signing/sending), non-guarantee caveat, and the return contents (success, compute units, program logs, error). Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% and the single 'tx' parameter is fully documented as 'Base64-encoded serialized Solana transaction to dry-run.' The description only adds the query-parameter form (?tx=), which is marginal value over 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?

States a specific verb ('simulate', 'dry-run') and resource (a serialized Solana transaction), and enumerates what it reports (success, compute units, program logs, error). The phrase 'BEFORE executing' and 'Pre-flight transaction simulation' clearly differentiate it from sibling execution/inspection tools like solmachina_tx_inspect or solmachina_verify_receipt.

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

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

Provides clear contextual guidance: use it BEFORE executing a transaction, as a pre-flight check. It also states the required input format (?tx=<base64 serialized transaction>). However, it does not explicitly name alternative tools or state when NOT to use it, though the purpose itself largely implies the use case.

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

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

Discloses it is a quote (not execution guarantee) and includes a 'not financial advice' disclaimer, plus mentions the use of Jupiter aggregator. Since no annotations are provided, this carries the full burden and 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 moderately concise with clear sentences, though it repeats disclaimers and the 'Requires' line is redundant with the schema. It is not overly verbose.

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

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

Provides enough context about the output (impact per size, depth summary) and the specific thresholds (1%/5% impact) to set expectations, despite lacking an output schema.

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 already describes all parameters with high coverage. The description adds minimal extra meaning beyond restating the required parameters and mentioning 'decade multiples' which is already implied by the 'mults' parameter 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?

Clearly states it quotes a slippage/price-impact curve by trade size using Jupiter aggregator, distinguishing it from a single quote and thus from sibling tools like dex_quote.

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

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

Provides context that it is 'beyond a single /v1/dex-quote' and clarifies it is a quote not an execution guarantee, giving the agent a sense of when to use it, though it doesn't explicitly list alternatives 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 of behavioral disclosure, and it does well: it explains the risk index meaning, transparency of components, confidence as data completeness, the verdict-free approach ('unknown' over guessing), and the requirement for a mint parameter. However, it doesn't disclose potential rate limits or failure modesspecifically, but these are less critical for a read-only scoring tool. It also includes a disclaimer that it's not financial advice, which is helpful.

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, well-structured paragraph that front-loads the core purpose and value proposition. It is efficient, but includes a mix of technical details and disclaimers. It could be split into bullet points for clarity, but it is concise without redundant 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?

Given the simple tool (one parameter, no output schema), the description covers the key aspects: what it does, how to use it (mint parameter), behavior (unknown over guessing), and differentiation. There is no output schema to explain return values, but it accurately describes the output (0-100 index, components, band, confidence). It is mostly complete for an agent to decide and 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 covers 100% of the parameters, including the mint parameter with a full description and an example. The description adds context about the index meaning and that mint is required, but doesn't add parameter-specific semantics beyond what the schema provides. Hence, 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 computing the SolMachina Machine Risk Index (SMRI) for an SPL token, with a 0-100 scale, transparent components, risk band, and confidence. It explicitly differentiates from siblings by positioning it as the cheap, high-frequency score for agents wanting just the number, and clarifies it is verdict-free and returns 'unknown' over guessing. This distinguishes it from solmachina_token_risk and related 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 states 'for agents that just want the number', clearly indicating the intended use case. It mentions the cheap, high-frequency nature and that it is verdict-free, which implies when to choose this over more comprehensive tools. It does not explicitly name alternatives or exclusion criteria, but the context against siblings is reasonably clear.

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

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

There are no annotations (e.g., readOnlyHint, destructiveHint) and the description does not disclose whether the tool is read-only, mutating, or has side effects. The term 'snapshot' implies a read operation, but this is not explicit, and the 'FREE' note is irrelevant to behaviour.

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, using a compact list format to convey the output components. Every word adds value, and there is no redundancy or fluff. It is perfectly sized for the 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?

Since there is no output schema, the description must convey what the tool returns, and it does so by listing the key fields (version, uptime, WAL entry count, SHA-256 chain head). It is sufficient for an agent to know what to expect, though it does not discuss error conditions or formatting.

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 coverage is effectively 100%. The description does not need to explain parameters, and it does not add any parameter-specific meaning. The baseline score of 3 is appropriate since there is no parameter information to augment.

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 a 'trust/health snapshot' and lists the specific components (version, uptime, WAL entry count, SHA-256 chain head). It is specific about what the tool reports, though it lacks an explicit verb describing the 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 does not provide any guidance on when to use this tool versus the many sibling tools. It does not mention typical use cases or scenarios where this status check would be preferred, leaving the agent to infer from the name and 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 description carries the burden. It discloses cache TTL and the fresh bypass, but does not confirm read-only behavior or possible 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?

Two concise sentences with no redundant wording; key details are front-loaded and scannable.

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?

Mentions output metrics (p50/p95/p99/EMA) and cache semantics, though the exact return shape is not specified. Adequate for a simple data lookup 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 sole parameter 'fresh' is well-explained in the schema, and the description adds the 'otherwise cached' contrast for clarity.

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?

Clear resource (Jito bundle tip floor) and action (snapshot + rolling history) with specific metrics. Distinguishes from sibling tools like priority_fee, though not explicitly by name.

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

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

Explains cache behavior and the fresh=true bypass, but does not explicitly state when to prefer this tool over related alternatives such as priority_fee.

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 key limitations: 'Owners are NOT resolved and an account is not necessarily a distinct wallet; concentration is a structural signal, NOT a verdict.' It also warns about stablecoin limitations and includes 'NOT financial advice.' It does not describe the exact return structure, but the output content is summarized (top accounts, concentration, buckets). This is substantial transparency for an unannotated tool.

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

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

The description is dense and efficient, front-loading the primary purpose before adding caveats. Every sentence provides unique value: purpose, differentiation, output scope, limitations, and usage requirement. No fluff or repetition, and it is structured logically from core function to 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 single-parameter read tool with no annotations or output schema, the description covers purpose, usage, limitations, and output summary adequately. It does not detail error handling or exact response format, but the agent has enough information to call the tool correctly. The limitation warning about stablecoins is critical and provided.

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 provides 100% coverage of the mint parameter with an example and caveat. The description adds value beyond the schema by explicitly stating the mint requirement and warning about stablecoins having too many accounts. This extra context helps the agent understand when the tool is appropriate, exceeding the baseline for high 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 clearly states the tool's purpose: 'Solana SPL token holder distribution / whale map' with specific output details (largest accounts up to 20, concentration metrics, buckets). It also explicitly differentiates from a sibling: 'More detailed than /v1/token-risk's single top-10 signal.' This is a specific verb-resource combination with clear 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?

The description gives a clear condition for use ('More detailed than /v1/token-risk') and an explicit exclusion ('Major stablecoins like USDC have too many accounts to snapshot'). It also states the required parameter (?mint=). However, it does not mention when to prefer alternatives beyond token-risk, leaving some ambiguity for other sibling tools.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool is verdict-free, conservative, leaves unknowns unresolved, exposes owners, and is not financial advice. It does not mention side effects or data sources, but the read-only analysis nature is clear.

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

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

The description is compact and front-loads purpose, then lists components and caveats. Some phrases are slightly repetitive or promotional ('one-call', 'full', 'decision-ready'), but no unnecessary sections are present.

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

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

There is no output schema, so the description must explain what is returned. It names the three outputs (risk analysis, executive digest, holder classification) and states handling of unknowns, but it does not describe output structure, fields, or error behavior, leaving some ambiguity for a complex bundled 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 only parameter, mint, is fully described in the schema with a Base58 SPL token address and example. The description simply repeats the requirement without adding new constraints, so it adds little beyond the schema; schema coverage is 100%, hence baseline 3.

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

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

Description explicitly states it is a one-call Solana token intelligence bundle combining full token-risk analysis, an executive digest, and top-holder classification. This clearly identifies the tool's purpose and distinguishes it from sibling tools like token_risk and token_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?

The phrase 'one-call bundle' implies using this tool instead of calling separate risk/holder/decision tools, and 'Requires ?mint=...' gives an invocation detail. However, it does not explicitly name when to use it versus sibling alternatives or state 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?

Discloses conservative reporting ('unknown' over guessing) and transparent methodology, but does not mention side effects (likely read-only), rate limits, or behavior on invalid inputs. With no annotations, the description carries the full burden, and this is partial 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?

Two sentences with zero waste. Purpose is front-loaded, followed by methodology and a disclaimer. Every sentence adds value.

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

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

For a tool with one parameter and no output schema, it describes what it checks and its conservative nature, but lacks details on the output format or how results are presented, which an agent might need to interpret the response. The heuristic nature could benefit from example outputs.

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

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

Schema coverage is 100%, so the parameter is fully documented. The description only repeats the requirement to provide a mint address, adding no new meaning. Baseline 3 is appropriate since the schema handles the heavy lifting.

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

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

The description clearly states the tool performs a heuristic risk/signal scan for SPL tokens, listing specific checks (mint/freeze authority, Token-2022 extensions, holder concentration). It's a specific verb+resource and distinguishes itself from siblings by focusing on risk heuristics rather than generic token info.

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 alternatives like solmachina_token_holders or solmachina_token_intel. It only mentions the required parameter, not usage context or exclusions. The existence of a batch sibling (solmachina_batch_token_risk) is not referenced.

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 that the data is observed, from GeckoTerminal, and warns that high volume does not imply safety, adding meaningful behavioral context. The wording 'Observed trending' implies a read-only operation, though it doesn't explicitly state no side effects. This is adequate for a data 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 a single, compact paragraph that leads with the tool's purpose, lists return fields, adds a disclaimers about safety and financial advice, and ends with the limit parameter. Every sentence contributes information; there is no fluff, and it is well-organized for quick parsing.

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 tool with one parameter and no output schema, the description is quite complete. It enumerates the return fields (name, mint, price changes, volume, liquidity, FDV, market cap, tx counts, pool age), names the source, and gives the limit range. It could mention that results are snapshots or time-dependent, but this is a minor omission; an agent has enough to call it correctly.

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

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

The schema already fully documents the single parameter 'limit' with type, range, and default. The description repeats the limit info without adding new meaning. Since schema description coverage is 100%, the baseline of 3 applies; the description adds no extra semantic value beyond the schema.

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

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

The description names a specific resource (trending Solana tokens/pools), the ranking source (GeckoTerminal), and enumerates the exact fields returned. It also explicitly disclaims being a recommendation or prediction, which differentiates it from advisory siblings like solmachina_decision or solmachina_pretrade.

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 states it provides market-activity facts and is NOT a recommendation or prediction, giving clear negative guidance. It does not explicitly name sibling tools or enumerate when-not-to-use conditions beyond the disclaimer, so it lacks explicit alternative routing, but the context is clear enough for an agent to know it is for observational data rather than decision support.

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

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

With no annotations, the description carries full responsibility. It discloses the tool is read-only in nature (reports on-chain effects, never intent), lists the fields returned, and implies no side effects. It does not mention error handling or rate limits, but for a simple inspect 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?

Two sentences with no wasted words. The purpose is stated first, followed by the requirement. It is front-loaded and efficient.

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

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

For a tool with one parameter and no output schema, the description explains what the output contains (success/fee/compute-units, programs, balance deltas) and the input requirement. It does not detail error conditions or response format, but these are not critical for a low-complexity inspect 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 already describes the single parameter (sig) as a Base58 transaction signature, achieving 100% coverage. The description adds the note 'Requires ?sig=<transaction signature>', which is redundant but confirms the parameter is required. No additional semantic value beyond the schema is provided.

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 (decode) and resource (Solana transaction), and specifies the output (success/fee/compute-units, programs invoked, balance deltas). It also clarifies what it does not report (intent), distinguishing it from potential intent-focused tools. This is clear and distinct.

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: it decodes an existing transaction and reports on-chain effects only, never intent. It also instructs that a signature is required. However, it does not explicitly name alternatives or say when not to use this tool, leaving some ambiguity relative to siblings like solmachina_simulate or solmachina_verify_receipt.

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 two key behaviors: offline operation and being free, which are valuable. However, it does not describe what happens with invalid receipts, the output format, or potential errors, leaving behavioral ambiguity.

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 that front-loads the core purpose and includes the useful 'FREE' qualifier. No wasted words, and it immediately communicates 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?

Given the simplicity of a single parameter and no output schema, the description is adequate for basic use but omits details about the return value (e.g., a boolean or verification report) and error handling for invalid or tampered receipts. It could be more complete without being verbose.

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 provides a detailed description of the 'receipt' parameter (base64 value or JSON), achieving 100% coverage. The tool description adds no additional meaning about the parameter, so the baseline of 3 applies without further compensation.

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

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

The description clearly states the verb 'verify' and the resource 'a paid answer's Ed25519 SIR receipt', with the method 'OFFLINE' and purpose 'proof of what you paid for'. It is specific and distinct from siblings like solmachina_how_to_pay, which likely covers payment rather than verification.

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 (to verify a receipt offline and for free) but does not explicitly name alternatives or provide exclusion criteria. It lacks a clear 'use this instead of X' statement, leaving the agent to infer context from the phrase 'How to verify'.

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

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

With no annotations provided, the description carries the full burden and discloses meaningful behavioral traits: it is conservative ('unknown' over guessing), never renders a trust/scam judgment, and is explicitly not financial advice. This sets accurate expectations for how to interpret results. It omits error/rate-limit/auth details, but for a single-param read operation the key disclosures are present.

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

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

Three sentences with the core purpose front-loaded. The behavioral clause ('Transparent, conservative...') earns its place as critical disclosure, and the 'NOT financial advice' disclaimer is necessary for a trust-adjacent tool. Slightly wordy but 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?

The description lists the output categories (age, activity, SOL balance, SPL holdings, footprint band), which partially compensates for the absent output schema by telling the agent what to expect in the response. For a single-parameter tool with full schema coverage, the main remaining gap is the exact return format, which is minor here.

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 describes the address parameter as 'Base58 Solana wallet address to profile.' The description's mention of 'Requires ?address=<wallet address>' is redundant with the schema and adds no new semantic detail (e.g., format constraints or validation behavior). Baseline 3 is appropriate since the schema does the work.

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

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

States a specific resource (Solana wallet) and action (activity profile) with enumerated output dimensions: age, transaction activity, SOL balance, SPL token holdings, and footprint band. This clearly distinguishes it from the token-focused siblings (solmachina_token_risk, solmachina_token_holders) and tx-focused tools (solmachina_tx_inspect, solmachina_verify_receipt), which profile different resources.

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 a wallet-level activity/trust footprint is needed) and states the address requirement, but it never names sibling tools or gives explicit when-not-to-use conditions. With 26 siblings, explicit routing guidance would meaningfully help, though the distinct purpose partially compensates.

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