MolTrust MCP Server

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

With no annotations provided, the description must disclose behavioral traits. It mentions the credential is cryptographically signed with Ed25519 (JWS), which is useful. However, it does not state whether issuance is a write operation, if it requires authentication, is reversible, or what side effects occur. This is a significant gap for a mutation-like action.

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 well-structured. It opens with the core purpose, then lists credential contents, notes the signing method, and concludes with the parameter specification. Every sentence adds value, though the Args section could be integrated more tightly.

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 has an output schema (not shown) that likely covers return values, so that is not required. The description explains the input and the nature of the credential. However, it lacks information about prerequisites, error conditions, or whether issuance is idempotent. For a single-parameter tool, it is adequate but not fully 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 only says 'address' is a string. The description adds critical semantic detail: it must be a Base (EVM) wallet address with a 0x prefix, and it is the subject of the credential. This goes beyond the schema and effectively documents the 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 the action (issue), the resource (W3C Verifiable Credential of type AgentTrustCredential), and the subject (a wallet). It also enumerates the credential's contents, making the purpose unambiguous and distinguishing it from the sibling verify tool.

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

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

The description does not explicitly state when to use this tool versus alternatives like moltguard_credential_verify. It implies issuance but gives no conditions, prerequisites, or guidance on when to prefer this over other credential-issuing tools among the siblings. The distinction is left to inference.

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

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

No annotations are supplied, so the description carries the full burden of behavioral disclosure. It clearly discloses the signature algorithm (Ed25519) and the success behavior (returns payload if valid). It does not specify invalid-signature handling, but the core behavioral contract is well stated.

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

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

The description is six short lines, front-loaded with the action and followed by the single parameter definition. There is no filler, redundancy, or unnecessary detail.

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

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

For a single-parameter verification tool with an output schema present, the description covers purpose, parameter, and core success behavior. The only notable omission is explicit invalid-input handling, but the output schema likely covers error returns, and the tool is simple enough that the description is adequate.

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

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

Schema coverage is 0%, so the description must explain the parameter. It defines jws as a JWS compact serialization string from a MoltGuard credential, adding format and source context beyond the bare string type. This adequately compensates for the missing schema 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 states the exact action: verify a MoltGuard Verifiable Credential JWS signature. It names the resource and the verification mechanism (Ed25519), which distinguishes it from the many sibling verify tools by specific credential scope.

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

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

The description implies usage: use this when you need to validate a MoltGuard credential JWS. However, it does not explicitly mention alternatives or when-not-to-use conditions, despite the long sibling list containing several verify tools. No exclusion guidance 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 full responsibility for behavioral disclosure. It only lists what the tool returns and does not state whether it is read-only, whether it requires authentication, or what happens with invalid addresses. It does not contradict any annotations (none exist), but it fails to communicate side-effect or constraint information beyond the obvious 'get' action.

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 succinct and well-structured: a single purpose sentence, a bullet-like list of return contents, and a clear Args section. It is front-loaded with the primary action and avoids unnecessary verbosity. 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 single-parameter tool with no annotations and an output schema, the description covers the essential invocation details: what the tool does, what it returns, and the parameter format. It does not address potential edge cases or prerequisites (e.g., wallet must be registered), but these are not critical for basic usage. The description is largely complete, missing only deeper context like when to prefer it over simpler siblings.

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 only defines 'address' as a string with no description (0% coverage). The description compensates by specifying 'Base (EVM) wallet address (0x...)' in the Args section, adding format and chain context. This is valuable and makes the parameter actionable, though it could add more validation rules or examples.

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 action ('Get a detailed agent trust report') and the resource (Base wallet address). It distinguishes itself from siblings like moltguard_score by emphasizing 'detail' and listing specific return components (scoring breakdown, wallet history, ERC-8004, DID cross-reference, Sybil indicators), making its purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as moltguard_score or moltguard_sybil. It does not mention conditions, exclusions, or recommend this tool for certain scenarios. There is no 'use this when' or 'for a simple score use...' context, leaving the agent to infer 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 are provided, so the description carries the full burden. It discloses the scanning behavior (top 20 by volume) and the sorting (by anomaly score), which is useful. However, it does not state whether this is a read-only operation, mention any rate limits or authentication needs, or describe what the returned anomaly indicators look like. Given the tool is a feed, the description gives adequate context but could add more behavioral detail.

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

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

The description is two sentences with zero fluff. It front-loads the purpose and then provides the operational details (volume filter, sorting) in a compact, readable way. Every sentence earns its place.

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

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

For a tool with no parameters and an output schema (though not detailed here), the description fully covers what an agent needs to know: what it does, how it selects markets, and how results are ordered. There is no missing information that would prevent a correct invocation.

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

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

The tool has zero parameters, so the description does not need to explain any parameter semantics. The schema coverage is 100% trivially, and there is nothing to add beyond the description's explicit mention of the fixed scope (top 20 markets). This meets the baseline for no-parameter tools.

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') and resource ('top anomaly feed'), and immediately explains the scope: scans top 20 active Polymarket markets by 24h volume, filters for anomaly indicators, and sorts by anomaly score. This clearly distinguishes it from sibling tools like moltguard_score or moltguard_market, which focus on individual market scores or details.

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 you need a feed of high-integrity-concern markets. It does not explicitly name alternatives or exclusions, but the sibling list suggests other tools handle specific scoring or verification, so the context is clear enough for an agent to select it without confusion.

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 of disclosing side effects, permissions, and access requirements. It does not state that the tool is read-only, whether it makes external network calls to Polymarket, or whether it requires any preconditions. It only describes the analysis logic, which overlaps with purpose and adds no 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 definition is compact and front-loaded: the purpose sentence appears first, followed by the analysis details and a minimal Args section. Every sentence contributes, with no filler or redundant restatement of the schema.

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

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

Given that an output schema exists and there is a single parameter, the description covers the core input semantics and the analysis scope. However, it omits usage context (when to choose this over siblings) and behavioral safety declarations (read-only, side-effect-free), which are essential for safe invocation without annotations.

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 only defines market_id as a string with no description. The description adds 'Polymarket market/condition ID,' which gives the parameter meaning but not format, examples, or how to obtain it. With a single parameter and 0% schema coverage, this minimal explanation is adequate but not rich.

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 and resource: 'Check a Polymarket prediction market for integrity anomalies.' It then enumerates concrete analysis signals (volume spikes, price-volume divergence, liquidity ratios, outcome price spreads), which clearly separates it from sibling tools like moltguard_score or moltguard_sybil that likely address different concerns.

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. It neither names sibling tools nor states conditions like 'use when you suspect manipulation' or 'for a broader market overview use moltguard_feed'. The agent must guess which of the many moltguard_* and mt_* tools is appropriate.

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

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

With no annotations provided, the description carries the behavioral burden and does substantive work: it discloses the data signals analyzed (on-chain activity, ERC-8004 registration, USDC balance, counterparty diversity, MolTrust credentials) and the 0-100 output. It does not mention caching, staleness, or failure modes, but these are minor gaps for a read-only score 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?

The description is compact and well-structured: a one-sentence summary, a one-sentence behavioral explanation, and a brief Args annotation. Every sentence adds value 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?

For a single-required-parameter tool with an output schema, the description is complete enough. It identifies the input format, the scoring inputs, and the output range; the output schema can carry return-value details, so nothing essential 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 input schema provides no parameter description coverage, so the description fully compensates by explaining that address must be a Base (EVM) wallet address in 0x... format. This is exactly the semantic detail the schema lacks, giving an agent sufficient detail to call the tool correctly.

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 and resource: get an agent trust score for a Base wallet address, and specifies the score range (0-100). It is clear, though it does not explicitly differentiate itself from closely related siblings such as mt_get_trust_score or moltguard_credential_verify.

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

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

Usage is implied: use this tool when you need a numerical trust score for a Base wallet address. However, there is no explicit guidance about when not to use it or which sibling to prefer, so an agent must infer the boundaries between this and similar trust/verify 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. It goes beyond a simple 'scan' by detailing what it analyzes and how funding clusters are interpreted (funder sent ETH to many wallets → Sybil ring). This gives meaningful behavioral insight. However, it doesn't disclose potential limitations or side effects, though the operation is evidently read-only; still, the description adds value.

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, each adding value: purpose, analysis dimensions, and cluster logic. It is front-loaded with the primary action. It is slightly wordy but still efficient; no filler. The structure is clear 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?

Given the tool has an output schema (not shown), the description need not explain return values. It covers the input parameter, the analysis scope, and the detection logic, which is sufficient for an agent to call it correctly. It doesn't mention any prerequisites or edge cases, but for a simple scan tool with one parameter, this is adequate.

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 does by specifying that the address is a 'Base (EVM) wallet address (0x...)' – adding chain context and format that the schema's bare 'Address' field lacks. This is sufficient for the single parameter, though it doesn't elaborate on validation or example values.

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 verb ('Scan') and resource ('Base wallet') with a distinct purpose: detecting Sybil indicators. It lists concrete analyses (wallet age, transaction patterns, counterparty diversity, funding source) and even describes the cluster-tracing logic, which unambiguously distinguishes it from sibling tools like moltguard_score or moltguard_credential_issue.

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 use case ('to detect potential Sybil wallets') and gives enough context to know when it applies, but it does not explicitly exclude alternatives or state when not to use it. Since sibling tools serve clearly different functions (credentials, score, etc.), an agent can infer usage, but explicit routing would be stronger.

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 explicitly states 'Read-only', which is a useful behavioral disclosure given that no annotations are provided. It also indicates the output includes a verdict and decoded transactions, giving some sense of what the tool returns. However, it does not disclose details like whether the agent must be registered, whether the evidence is historical or live, or what happens if no breach exists. The read-only note is valuable but the behavioral picture is 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?

The description is compact and front-loaded with the core purpose ('Verdict plus the decoded transactions that breached the mandate'), followed by a clear read-only note and a parameter explanation. It is appropriately sized for a single-parameter tool, though the Args block is slightly redundant with the input 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?

The tool has an output schema, so return values are presumably documented there, and the description adds the key context that the output includes decoded transactions. With one parameter and a clear read-only note, the description is mostly adequate. However, it does not clarify how this tool relates to moltproof_verdict or moltproof_verify, which is a notable gap given the large sibling set.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'agent' parameter. The description says 'agent: public agent identifier (address / DID / ERC-8004 ref)', which adds meaningful format context beyond the schema's bare 'string' type. However, it does not explain how the identifier is used or what formats are accepted in practice, so it only partially compensates for the lack of 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 states a specific verb and resource: it returns a verdict plus the decoded transactions that breached the mandate. This distinguishes it from sibling tools like moltproof_verdict (which likely returns just the verdict) and moltproof_verify (which likely verifies something). However, it does not explicitly name a sibling or contrast itself, so it falls just 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?

The description implies usage: call it with an agent identifier to get evidence for a mandate breach. It does not explicitly state when to use this tool versus moltproof_verdict or moltproof_verify, nor does it mention any prerequisites or exclusions. The context is clear enough for an agent to infer the basic use case, but the lack of explicit alternatives leaves a gap.

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?

Annotations are absent, so the description carries the full burden. It explicitly states 'Read-only', which is a key behavioral disclosure. It also hints at the return content (venues, position cap, validity) but does not address error conditions, rate limits, or what happens when the agent is invalid. For a read-only operation with no annotation support, this is adequate 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?

The description is compact and front-loaded with the core purpose, followed by the read-only note and parameter explanation. Each element earns its place. The formatting is informal but readable; no 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 (one parameter, read-only) and has an output schema, so the description need not cover return structure. However, it omits usage context (when to call it) and edge-case behavior (e.g., unknown agent). With only a single parameter and low complexity, this is a moderate gap but not critical.

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 clarify the parameter. It does so by defining 'agent' as 'public agent identifier (address / DID / ERC-8004 ref)', which adds meaningful type context beyond the schema's bare 'Agent' string field. This is a clear improvement over the schema alone.

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

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

The description states a specific resource (committed AAE mandate) for an agent, with qualifying details (venues, position cap, validity). It distinguishes from siblings like moltproof_evidence or moltproof_registry by naming 'mandate' explicitly. However, 'AAE' is cryptic and may not be self-explanatory to an agent unfamiliar with the domain.

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 the many sibling tools. It does not mention alternatives or conditions such as 'use moltproof_verify for verification'. The only context is the resource it returns, leaving the agent to infer usage from the name.

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

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

With no annotations provided, the description carries the full burden and does contribute real behavioral value: it declares 'Read-only' and discloses the ranking policy ('Ranks NO_MANDATE / NEEDS_REVIEW lower'), which explains result ordering. However, it omits any detail on output volume, pagination, authentication, or what the verdict values mean, leaving several behavioral gaps.

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

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

Two sentences with no filler: the content scope is front-loaded, followed by the read-only guarantee and the ranking detail. It is appropriately terse for a zero-parameter read tool, though a leading verb would make it slightly stronger.

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 low complexity (zero parameters, no nested objects) and the presence of an output schema, the description covers the essentials: what is returned, that it is read-only, and how results are ordered. It is slightly thin on defining terms like 'committed mandates' and the verdict values, but the output schema compensates for those 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 takes zero parameters and the schema trivially covers 100% of them, so the baseline of 4 applies. The description correctly adds no parameter-specific text because there is nothing to document; the ranking note hints at implicit 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 identifies the resource ('Agents with committed mandates') and what it exposes ('their current verdict'), and the name 'registry' implies a listing. It lacks an explicit verb like 'list' or 'get', and doesn't explicitly contrast with siblings like moltproof_verdict or moltproof_mandate, but the aggregate/registry framing is enough to make the purpose reasonably 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?

No guidance is given on when to call this tool versus the 50+ siblings, particularly the closely related moltproof_verdict, moltproof_mandate, and moltproof_evidence. There are no when-to-use, when-not-to-use, or alternative-routing statements; the agent must infer placement purely from the name.

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

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

No annotations provided, so the description carries the burden. It explicitly states 'Read-only' and 'Recomputable from public chain data + the public mandate', disclosing that it is a deterministic read operation. It does not cover error handling or rate limits, but the core behavioral trait is disclosed.

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

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

The description is concise, with the main purpose first, followed by the read-only clarification and a clear args section. Every sentence earns its place, 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?

The tool has a single parameter, an output schema, and the description covers purpose, parameter formats, and read-only nature. It is complete enough for an agent to invoke correctly; output details are left to the schema. Minor gap: no mention of edge cases, but not critical.

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 only defines 'agent' as a string with no description. The description compensates fully by specifying accepted formats: agent address, did:moltrust / did:web, or ERC-8004 reference. This adds significant meaning beyond the schema.

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

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

The description clearly states a specific action: return a verdict and per-check breakdown for an agent against its mandate. It distinguishes itself from generic tools, though it does not explicitly name sibling alternatives like moltproof_verify.

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 when you need the verdict for an agent, but it does not mention alternative tools or when not to use it. No explicit guidance for choosing between this and moltproof_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?

No annotations are provided, so the description carries the full burden. It discloses that the tool is offline and read-only, which is a key behavioral trait. It also clarifies the signature is optional. However, it does not mention error behavior or what happens when verification fails, but the read-only disclosure is significant.

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 with the core purpose, followed by the offline/read-only note and a clean argument list. It is efficient with no redundant filler, though it repeats 'public' for multiple parameters, which is minor.

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 has an output schema, so return values need not be described. The input parameters are well explained, and the offline/read-only context is given. However, it does not specify expected input formats (e.g., structure of mandate or actions) or any error conditions, and it lacks explicit differentiation from sibling verify tools, leaving some ambiguity for an agent deciding which tool to invoke.

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%, but the tool description compensates by explaining each parameter: 'agent' as public identifier, 'mandate' as the public AAE Verifiable Credential, 'actions' as already-decoded on-chain actions, and 'signature' as optional prior signature. This adds substantial meaning beyond the bare schema types.

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 ('recompute', 'check') and resource ('verdict', 'signature'), making the tool's purpose immediately clear. It also explicitly notes it's offline and read-only, which distinguishes it from sibling verify tools that may fetch external data.

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

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

The description implies usage for verification without external fetching ('offline and read-only'), but it does not explicitly name alternatives or exclusion conditions. Given the many sibling verify tools (e.g., moltguard_credential_verify, moltrust_verify), more explicit guidance would improve selection accuracy.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the conversion rate (1 USDC = 100 credits), the on-chain verification step, and the required prior deposit. It does not list failure modes or whether a tx_hash can only be claimed once, but for a simple claim tool it provides meaningful behavioral context beyond the 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?

The description is compact and front-loaded, with the core action in the first sentence. The additional workflow, conversion rate, and parameter notes each add necessary value with no filler or repetition of schema information.

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

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

The tool has only two required parameters and an output schema, so the description doesn't need to explain return values. It provides the prerequisite workflow, the conversion rate, and clear parameter semantics, leaving no obvious gap for an agent 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?

Schema description coverage is 0%, so the description must compensate. It does so fully: tx_hash is explained as a Base blockchain transaction hash with the 0x... format, and did is explained as 'Your agent's DID to credit.' This is exactly the semantic meaning missing from the input 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 opens with a specific verb and resource: 'Claim MolTrust credits from a USDC deposit on Base.' It clearly identifies both the action and the source, and it is distinct from sibling tools like moltrust_deposit_history or moltrust_deposit_info because it focuses on the redemption action rather than viewing deposits.

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 prerequisite: 'After sending USDC to the MolTrust wallet on Base (L2), submit the transaction hash to receive credits.' This tells an agent when it is appropriate to call the tool. It doesn't explicitly name alternative tools or exclusion cases, but the deposit-claim flow is unambiguous enough that no misleading alternatives exist.

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 behavioral burden. It does disclose that the tool either issues or verifies a credential and that parameter requirements depend on the action. However, it does not mention side effects, permissions, or the scope/trust assumptions of verification, though the presence of an output schema reduces the need to describe return values.

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 the core purpose and then uses a compact, scannable Args list. Every line conveys necessary information: action, conditional requirements, defaults, and JSON format. There is no filler or redundant restatement of the tool name.

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

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

The parameter documentation is strong and the output schema covers return values, but the description is incomplete for tool selection given the many overlapping sibling tools. It lacks any guidance on how this credential tool relates to moltguard_credential_issue/verify, moltrust_verify, or the various domain-specific verify tools. This makes contextual routing 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?

Schema description coverage is 0%, so the description fully compensates. It explains every parameter: 'action' as issue/verify, 'subject_did' as the subject DID required for issue, 'credential_type' as defaulting to AgentTrustCredential and only for issue, and 'credential' as a JSON string required for verify. This goes well beyond the bare schema.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Issue or verify a W3C Verifiable Credential.' It accurately conveys the dual-action nature. However, it does not distinguish itself from overlapping siblings like moltguard_credential_issue, moltguard_credential_verify, or moltrust_verify, so it misses 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?

The description explains that 'action' can be 'issue' or 'verify' and notes conditional parameter requirements, but it gives no guidance on when to choose this unified tool over the several similarly named sibling issue/verify tools. There are no exclusions, alternatives, or routing hints, which is a significant gap given the large sibling set.

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 not state whether 'transfer' is irreversible, whether any action requires authentication, what happens on insufficient balance, or what side effects occur. It only labels the actions, leaving important behavioral traits undisclosed.

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 one-line purpose summary followed by a compact, well-organized Args block. Every line adds necessary operational or parameter-level information, with 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?

For a multi-action dispatcher with seven parameters and no annotations, the description is largely complete: it enumerates all actions, their required arguments, and pagination defaults. The presence of an output schema reduces the need to explain return values. The main gap is the lack of behavioral context around the transfer side effect and any required permissions.

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%, but the description compensates by explaining every parameter's role, conditional requirements, and constraints. It clarifies that 'did' is required for balance/transactions, 'to_did' and 'amount' for transfer, and it documents pagination defaults. This is exactly the semantic guidance an agent needs beyond the raw schema.

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

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

The description states a clear resource ('MolTrust credits') and enumerates four concrete operations: check balance, view pricing, transfer credits, and view transaction history. It is easily understood and specific, though it does not explicitly differentiate itself from potentially overlapping siblings like moltrust_deposit_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?

The description provides clear per-action usage guidance: it lists the accepted action values and identifies which arguments are required for each action, including defaults for limit and offset. It does not mention alternatives or exclusions, but the action-driven context is strong enough for an agent to know when to call the 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 provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, read-only guarantees, authentication requirements, or output characteristics. The verb 'Get' implies a read, but this is not explicitly stated, and no additional behavioral context is given.

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, with a single sentence and a parameter line. It is front-loaded with the action and resource, and every word serves a purpose. However, it is so brief that it borders on under-specification, which slightly reduces the score, but for what it does include, it is efficiently 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?

Although an output schema exists (which lessens the need to describe return values), the description lacks crucial context: no usage guidance, no parameter depth, and no behavioral transparency. For a one-parameter tool, it is minimal but leaves the agent with little practical understanding of how to use it correctly or interpret results.

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 does add that 'did' is 'The agent's DID', which gives a minimal semantic hint beyond the schema's 'Did' label, but it does not explain what a DID is, its format, or how it is used. This is barely more than a restatement of the parameter name, providing marginal added 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 clearly states the action ('Get') and the resource ('USDC deposit history') for an agent, making the core purpose unambiguous. It does not explicitly differentiate from siblings like moltrust_deposit_info, but the specificity of 'USDC deposit history' is enough for a basic understanding.

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 such as moltrust_deposit_info or other history-related tools. There are no exclusions, prerequisites, or context about typical use cases, leaving the agent without 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 provided, the description must carry the behavioral disclosure burden itself; it does convey that this is a read-only information-returning call and lists the expected outputs. However, it does not mention external dependencies, whether the conversion rate is current, or any side effects, leaving full transparency 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?

The description is short, front-loaded with the action, and each subsequent clause adds concrete return-value detail: wallet address, USDC contract, conversion rate, and instructions. There is no filler or gratuitous restatement beyond minor reuse of 'instructions.'

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-argument information tool with an output schema, the description is complete: it names the data returned and the intended use. An agent does not need additional context to select and invoke this 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 has zero parameters and schema description coverage is 100%, so there is no parameter information the description needs to add beyond the schema. The 0-parameter baseline applies here, and the description introduces no input 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 specific verb and resource ('Get USDC deposit instructions') and clearly states the purpose (buying MolTrust credits). It distinguishes itself from siblings such as moltrust_claim_deposit and moltrust_deposit_history by being the informational 'how to deposit' tool.

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

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

The phrase 'to buy MolTrust credits' gives a clear use context: use this when an agent needs USDC deposit instructions for purchasing credits. It does not explicitly name exclusions or alternatives, so it falls just short of a 5.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It uses verbs like 'Query', 'Resolve', 'fetch', and 'look up' implying read-only behavior, but it never explicitly states that the tool is non-destructive or has no side effects. It also does not mention rate limits, costs, or the nature of the 'well-known' action, leaving some 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 concise and front-loaded: the main purpose is stated in the first sentence, followed by a clear action list and parameter details. Every sentence serves a purpose, with no wasted words or redundant explanations.

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 three actions and parameter requirements adequately, and the presence of an output schema (though not shown) reduces the need to describe return values. It omits details on the 'well-known' action and potential error conditions, but overall it gives an agent enough to invoke the tool correctly for the primary 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?

Schema description coverage is 0%, so the description must fully explain the parameters. It does this excellently: it lists the three valid action values, specifies which parameter is required for which action, and provides concrete examples for did and agent_id. This adds substantial meaning beyond the bare schema types and defaults.

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 queries the ERC-8004 on-chain agent registry on Base, and enumerates three specific actions (card, resolve, well-known) with distinct resources. It differentiates from all sibling tools, none of which mention ERC-8004 or on-chain registry lookups.

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

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

The description provides clear context by specifying which parameter is required for which action (e.g., did for 'card', agent_id for 'resolve'), giving the agent enough to decide when to call it. However, it does not explicitly name alternatives or state when not to use this tool, though the sibling set makes the niche obvious.

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 'Submit a trust rating' without indicating side effects such as permanence, overwriting previous ratings, authentication requirements, or whether the rating is one-way. Since this is a write operation, the agent would benefit from knowing if it can be undone or if it requires prior registration. The description lacks these details.

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

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

The description is concise, with a clear two-sentence summary followed by a structured argument list. The purpose is front-loaded, and the parameter list is easy to scan. No extraneous words. It earns a 4 because it is efficient 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 simple three-parameter tool with an output schema, the description is mostly adequate. It covers the purpose and parameters. However, it omits behavioral context such as whether the rating is permanent, whether it can be updated, and any prerequisites (e.g., both agents must be registered). Given that no annotations exist, these missing details make the description incomplete for an agent that needs to understand side effects before invoking the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by explaining each parameter: from_did (the rater), to_did (the rated agent), and score (with a range from 1 to 5). This adds meaning beyond the schema, which only lists types. The description also clarifies the semantic of the score ('untrusted' to 'highly trusted'), which is helpful. It could add constraints like DID format or registration requirements, but the provided explanations are solid.

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 action ('Rate another AI agent') and the resource (an AI agent), with a concise summary ('Submit a trust rating from one agent to another'). It is specific and not a tautology. However, it does not explicitly differentiate from sibling tools like mt_endorse_agent or moltrust_reputation, which might have overlapping purposes. The name 'moltrust_rate' and the 1-5 star scale make it fairly distinct, 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?

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., whether agents must be registered) or conditions under which rating is appropriate. It simply describes the operation. An agent would have to infer usage from the context, and with many sibling tools, this lack of explicit routing is a gap.

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 transparency burden, and it delivers: it discloses the side effects of the operation (DID creation, VC issuance, on-chain anchoring on Base), which signals a mutating, blockchain-writing action. This goes well beyond the tool name and schema. Minor gaps remain — no mention of gas costs, irreversibility, or duplicate-registration behavior — but the core behavioral profile is honestly and usefully disclosed.

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

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

The description is five compact lines with zero fluff: a front-loaded action line, a brief process paragraph that earns its place by explaining the mechanics, and a clean Args block that maps directly to the two parameters. No sentence is redundant or decorative.

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 fully specified for its 2-param surface, an output schema exists (so return values need no explanation), and the behavioral steps are disclosed. The only genuine omissions are operational concerns for a blockchain-anchoring action — whether it incurs gas costs, requires a wallet/credits, or fails on duplicate registration — which an agent might need to avoid surprises. These are secondary, not crippling, given how well the core semantics are covered.

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 bare schema offers only titles, leaving the description to carry all meaning. The Args block fully compensates: display_name gains a length range and allowed character set (1-64 chars, alphanumeric/dash/underscore/dot/space), and platform gains concrete examples ('openai', 'langchain', 'custom'). This is exactly the kind of semantic enrichment that makes correct invocation possible.

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 ('Register a new AI agent on MolTrust') and expands into the concrete multi-step behavior: creating a DID, issuing a W3C Verifiable Credential, and anchoring on the Base blockchain. This clearly separates it from credential-issue siblings like moltguard_credential_issue or mt_issue_badge, which lack the registration/DID creation framing. The blockchain anchor detail makes the tool's identity 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?

The first line implies the usage context — this is the tool for registering a new AI agent — but nothing is said about when to prefer it over the many issuing/verifying siblings, nor any exclusions or prerequisites. In a 51-tool suite dense with credential tools (moltguard_credential_issue, moltrust_credential, mt_shopping_issue_vc), an explicit pointer to alternatives would materially help. The usage is clear by implication, not by 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 carries the full burden of explaining behavior. It states the return values (aggregate trust score and total ratings) and the action 'Get', which implies a read-only operation. However, it does not disclose edge-case behavior (e.g., invalid DID, non-existent agent) or any rate limits or permissions, which are relevant 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 compact and well-structured: a one-line purpose, a one-line return summary, and a clear Args section. Every sentence adds value, and the key action is front-loaded. There is no fluff or redundant information, making it easy for an agent to parse quickly.

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, single-parameter query tool with an output schema, the description covers the essential elements: what it does, what it returns, and how to provide the DID. It omits any mention of error conditions or registration prerequisites, but these are not critical given the tool's simplicity. The presence of an output schema reduces the need to fully enumerate return fields in prose.

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?

Since schema description coverage is 0%, the description must compensate for the single parameter. It does this well by explaining that 'did' is a Decentralised identifier and providing a concrete example format ('did:moltrust:a1b2c3d4e5f60718'). This adds meaning beyond the schema's bare type string, giving the agent enough context to construct a valid 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 clearly states the verb and resource: 'Get the reputation score for an AI agent.' It also specifies the return values, which helps differentiate from rate/verify tools. However, it does not explicitly distinguish itself from the sibling mt_get_trust_score, leaving some ambiguity about which tool to pick when a trust score is needed.

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 alternatives such as mt_get_trust_score, moltrust_verify, or moltrust_rate. It only describes what the tool does, without any context about prerequisites, exclusions, or preferred scenarios. This leaves the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It states the tool returns metrics but does not explicitly confirm it is read-only, mention authentication requirements, rate limits, or any side effects. The description adds minimal behavioral context beyond the output content.

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 exceptionally concise, using two sentences to convey purpose and return contents. The primary purpose is front-loaded, and every word adds value without redundancy. It is well-structured 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 zero-parameter stats tool with an output schema present, the description fully covers what an agent needs to know to invoke it correctly. It lists the expected metrics and the tool's scope, leaving no ambiguity about its functionality or expected return.

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 schema coverage is inherently 100%. The description does not need to explain parameters, and the baseline for 0 params is 4. It appropriately omits parameter details since none exist.

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 action 'Get MolTrust network statistics' and enumerates specific metrics returned (registered agents, credentials issued, ratings, health metrics). It distinguishes itself from sibling tools like moltrust_credential or moltrust_rate by being the aggregate stats 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 description implies usage for retrieving overall network health metrics but does not explicitly state when to prefer this over alternatives or provide exclusions. It gives no guidance on context or when not to use it, leaving the agent to infer based on the tool name and purpose.

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 output content (verification status, trust card with reputation, credentials, blockchain anchor) and implies a read-only operation, but it does not mention any side effects, error behavior for unregistered DIDs, or prerequisites. The existence of an output schema partially covers return format, but behavioral traits beyond that are limited.

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 well-structured: a one-line purpose, a two-sentence elaboration, and a single argument definition. Every sentence earns its place, and the key action is front-loaded. There is no redundancy or 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 tool with one parameter and an output schema, the description is nearly complete. It states what it does, what it returns, and how to supply the argument. The only notable gap is guidance on differentiating from other verify tools or handling unregistered DIDs, but given the simplicity, it is sufficient for an agent to call it correctly.

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

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

The input schema provides only a bare 'did' property with no description (schema coverage 0%). The tool description compensates by including an Args section that defines the DID as a 'Decentralised identifier' and gives a concrete example ('did:moltrust:a1b2c3d4e5f60718'). This adds meaningful format and usage context that the schema alone lacks.

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 and resource: 'Verify an AI agent by its DID.' It then states precisely what it does (checks registration) and what it returns (verification status and trust card details). This clearly distinguishes it from sibling verification tools like moltproof_verify or mt_shopping_verify, which target different 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 implies usage when you have a DID and want to verify an agent's registration and trust card, but it does not explicitly contrast with alternatives or state when not to use it. For instance, it does not mention that verification of specific credentials might require other tools like moltrust_credential. The context is clear but exclusions are absent.

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 behavioral disclosure burden. It states the output shape (yes/no with tier and expiry), which is helpful, but does not explicitly mention whether the operation is read-only, has side effects, or what the 'tier' and 'expiry' semantics mean. 'Quick check' implies non-mutating but this is 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 very concise, front-loads the purpose in the first sentence, includes the return type, and lists the argument with a brief explanation. No unnecessary words or repeated schema 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 one-parameter tool with an output schema, the description covers the core purpose, parameter, and return type. It does not discuss errors or prerequisites, but the low complexity and presence of an output schema make this acceptable. The main gap is usage guidance, which is scored separately.

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 parameter. It provides a one-line explanation ('The DID of the agent to check') which adds meaning beyond the schema's bare title, but does not include format, examples, or constraints. This is minimal but adequate for a single, self-explanatory 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 a specific verb ('check') and resource ('badge-verified by MolTrust'), and mentions the return type (yes/no with tier and expiry). It is easy to understand, though it does not explicitly distinguish itself from the many sibling verification tools like mt_get_badge or moltproof_verify.

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 such as moltguard_credential_verify, moltrust_verify, or mt_get_badge. The description implies a quick badge check but gives no exclusions or selection criteria.

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

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

With no annotations provided, the description carries the full burden. It discloses the return values (evidence_hash, base_tx_hash), the blockchain (Base L2), and the validity period (72 hours). It also indicates this is a creation (mutation) operation. However, it does not detail potential side effects, idempotency, or error conditions, which would be valuable for a transaction-creating 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-structured. The first two sentences convey purpose and key returns, followed by the dependency and validity. Parameter explanations are listed compactly. There is no redundancy, and the most critical 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 covers purpose, usage prerequisite, validity, return values, and parameter semantics. It is complete for a tool of this complexity. Minor gaps include lack of mention of error handling, expiry behavior, or required permissions beyond the api_key. Given the presence of an output schema and the clarity of the description, it is sufficiently 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 description provides detailed semantics for all five parameters: api_key, agent_a, agent_b, interaction_type, and outcome. It even includes examples for interaction_type and outcome. Since the schema itself has no descriptions (0% coverage), this is essential and fully compensates. Each parameter's meaning is clarified beyond just name and type.

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 specific action ('Create an interaction proof') and its context ('before issuing a SkillEndorsementCredential'). It also names the dependent sibling tool (mt_endorse_agent), distinguishing this tool's purpose. The mention of return values (evidence_hash, base_tx_hash) further clarifies its function.

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 states when to use this tool: 'Required before calling mt_endorse_agent' and 'Valid for 72 hours.' This provides clear timing and a prerequisite. It does not mention alternatives, but given the sibling list, this tool is a unique step in the workflow, so that is acceptable. The guidance is strong but not exhaustive.

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 disclose behavior. It does so by noting that the action 'Contributes to the endorsed agent's Trust Score' and that self-endorsement is rejected, plus the freshness constraint on evidence. It stops short of describing error cases or whether the credential is publicly visible, but for a credential issuance tool these are the key side effects an agent needs to know.

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 well-organized: a one-sentence purpose, then two prerequisite/effect statements, then a clean bulleted list of arguments. It is concise yet complete, with no fluff or redundant phrasing. The most important info is front-loaded, and the args list is 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 tool with six required parameters and zero schema documentation, the description covers all necessary operational details: purpose, prerequisites, param meanings, allowed enum values, and side effects. The output schema (which exists) presumably documents the return value, so the description does not need to repeat it. An agent can confidently invoke this tool after reading the 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 provides zero descriptions for all six parameters (coverage 0%). The description compensates fully: it explains each parameter's meaning, gives the allowed values for 'skill' and 'vertical', and specifies the source and format for 'evidence_hash' (sha256:...) and 'evidence_timestamp' (ISO 8601). This is essential because an agent would otherwise have no way to know 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 opens with a precise verb and object: 'Issue a W3C SkillEndorsementCredential for another agent.' This clearly distinguishes it from siblings like mt_skill_issue_vc (which likely issues a skill credential to self) and mt_create_interaction_proof (which is the prerequisite evidence generator). The tool's role 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 states a clear prerequisite ('Requires a valid evidence_hash from mt_create_interaction_proof (max 72h old)') and an exclusion ('Self-endorsement is rejected'), which tells an agent when it is valid to call. It implies the workflow (create proof first, then endorse) but does not explicitly name alternatives or say 'use this instead of X'. However, the context is strong enough for a competent agent to infer the intended 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 full burden of behavioral disclosure. It mentions SHA-256, tamper-proof, and 'anchored on Base L2', implying an on-chain write operation. However, it fails to disclose critical side effects such as irreversibility, potential network fees, or the need for a funded wallet. For a commitment that likely creates a permanent record, this is a significant omission.

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 structured with an Args section and front-loads the core purpose. It is moderately long due to the 10 parameters, but each line earns its place by providing examples or constraints. It could be tightened, but given the parameter count, it is appropriately sized.

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 an output schema present, return values are covered. However, the description misses operational context such as whether a wallet is required, if the operation is irreversible, or if there are fees. These are relevant for an on-chain commitment. It also doesn't mention verification via mt_fantasy_verify. Given the complexity and the blockchain aspect, some critical context 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 0%, so the description must compensate. It does so excellently: it lists all 10 parameters with examples (e.g., agent_did, contest_id, lineup_json), specifies allowed values for platform and sport, and notes constraints like contest_start_iso must be in the future. This adds substantial meaning beyond the bare schema and is essential for correct invocation.

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 action (commit a fantasy lineup) and the resource (fantasy lineup), with specific details about SHA-256 hashing and W3C VC creation. It differentiates from siblings like mt_fantasy_verify and mt_fantasy_history by focusing on the commitment action, though it doesn't explicitly name alternatives. The purpose is unambiguous and distinct from other 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 implies when to use it (before contest start to lock a lineup) but does not explicitly state when not to use it or mention alternatives. Given siblings like mt_fantasy_verify and mt_fantasy_history, the description lacks explicit routing guidance. The context is clear but there are no exclusions or comparisons.

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. 'Get' and 'Returns' imply a read-only operation and specify what the caller receives, but the description does not disclose side effects, authentication needs, rate limits, or how 'recent lineups' is bounded.

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 purpose in the first sentence. There is minor redundancy between 'for an agent' and 'for the specified agent DID,' but the overall length 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 simple getter with one parameter and an output schema, the description covers purpose, return categories, and parameter format. It lacks explicit usage routing and boundary details like the definition of 'recent,' but nothing essential is missing for an agent to call 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?

Schema coverage is 0%, but the Args section compensates by explaining the sole parameter's meaning and providing a concrete DID format example ('did:moltrust:a1b2c3d4e5f67890'). This is sufficient for a single-parameter tool.

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

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

The description opens with a clear verb and resource: 'Get fantasy lineup history and stats for an agent.' It names the key returned metrics, which is enough to understand the tool's purpose, though it does not explicitly call out how it differs from sibling tools like mt_fantasy_commit or mt_fantasy_verify.

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 about when to use this tool rather than any of the many siblings. The only contextual hint is 'for the specified agent DID,' which states what input to provide, not when this tool is the appropriate choice or when an alternative might be better.

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 endpoint is public and requires no auth, and enumerates the returned data (lineup, timing proof, on-chain status, credential). However, it does not explicitly state that verification is read-only, nor does it describe behavior for invalid or missing hashes. It adds some context but leaves gaps in side-effect disclosure.

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

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

The description is concise and well-structured: a one-line purpose, a return summary, and a clear Args section. It is front-loaded with the purpose and does not waste words, though it could be slightly more 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?

With an output schema present and one parameter fully described, the description is largely complete for a simple verification tool. It could mention error handling or edge cases, but these are likely covered by the output schema. It provides sufficient information 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?

The description provides the parameter format ('64-char SHA-256') and its role ('commitment hash'), which is essential because the schema has 0% description coverage. This fully compensates for the missing schema documentation, giving an agent clear 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 the action ('Verify') and the specific resource ('a fantasy lineup commitment'), distinguishing it from other verify tools in the sibling list. It also lists what it returns (lineup, timing proof, on-chain status, credential), which further clarifies its purpose. The name alone is informative, but the description adds concrete scope.

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

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

Usage is implied: use it to verify a fantasy lineup commitment. However, it does not explicitly contrast with sibling tools like mt_fantasy_commit or other verify endpoints, nor does it state when not to use it. There are no alternatives or exclusions mentioned, so an agent must infer the context from the resource name.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does mention the output contents (badge tier, trust score, dates, SVG URL), which is helpful, but it does not explicitly state that the operation is read-only, lacks error behavior, or note any access considerations. This is partial transparency but not comprehensive.

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 well-structured: a one-sentence purpose, a bullet-like list of returns, and a single arg line. It is front-loaded with the core action and avoids filler, though the 'Args:' section could be formatted more cleanly.

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 getter with one parameter and an existing output schema, the description covers the essentials: what it does, what it returns, and what to pass. Still, it omits any mention of when to prefer this over the many similar sibling tools, and the absence of annotations leaves behavioral context incomplete.

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. The line 'did: The DID of the agent to check' provides a basic meaning for the lone parameter, which is more than the schema gives. However, it does not elaborate on format, validation, or examples, leaving room for 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 clearly states a specific action ('Get') and resource ('Verified by MolTrust badge status'), with concrete return fields listed. However, it does not differentiate from the similarly named sibling mt_check_badge, so full 5 for sibling distinction is not earned.

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 like mt_check_badge, mt_issue_badge, or moltrust_verify. There are no usage conditions, exclusions, or references to sibling tools, so an agent is left to guess which one fits the scenario.

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 disclosure burden. It does disclose the 2-hop scope and the returned nodes/edges, and the verb 'Get' implies a read-only operation. It does not mention authentication requirements, behavior for unknown DIDs, pagination, or data freshness, leaving some gaps.

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

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

The description is compact and front-loaded: the core purpose appears in the first sentence, followed by a concise return summary and an Args section. Every sentence contributes value with no repetition or 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 single-parameter, read-only graph query with an output schema, the description is largely complete: it explains what the graph represents, the hop limit, and the output structure. It is missing usage guidance and failure behavior, but these are 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?

Schema description coverage is 0%, so the description must compensate. It adds 'DID of the agent to get graph for', which clarifies the parameter's role and purpose, but it does not provide format expectations, examples, or edge-case meaning beyond a simple restatement.

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 gets a trust propagation graph for an agent, limited to 2 hops, and specifies the return shape (nodes and edges). It does not explicitly differentiate itself from sibling tools like mt_get_trust_score or mt_get_swarm_stats, so it misses the top 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?

Usage context is implied by the purpose: use it when you need a 2-hop trust graph for a DID. However, it provides no explicit guidance on when to choose this over sibling graph/trust/score tools, and no exclusions or alternative recommendations.

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 provided annotations, the description carries the burden of behavioral disclosure. 'Get' implies a read-only operation, and the description lists what the tool returns, but it does not explicitly state non-mutation, authentication needs, rate limits, or caveats about data freshness. The basic behavior is clear, though more transparency 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 tight sentences with no filler. It front-loads the core purpose, then enumerates the returned statistics in a scannable list. 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?

This is a simple zero-parameter read tool with an output schema present. The description fully explains what the global statistics contain and signals the global scope. Nothing needed to invoke 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?

The tool has zero parameters and full schema coverage, so there is nothing for the description to explain about parameters. Per the rubric, zero-parameter tools receive a baseline of 4, and the description adds relevant context about the returned fields.

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

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

The description states a specific verb ('Get') and resource ('global Swarm Intelligence statistics'), then lists the exact data returned. This clearly distinguishes it from sibling tools like mt_get_swarm_graph, which would return structural graph data, and moltrust_stats, which appears focused on trust/reputation stats.

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 explicit guidance on when to use this tool versus alternatives. It implies usage through 'global statistics,' but never names conditions, exclusions, or sibling tools, so an agent must infer the right context from the tool name alone.

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

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

With no annotations provided, the description carries full behavioral disclosure burden. It does not explicitly state that the operation is read-only (though 'Get' implies it), nor does it mention authentication, error conditions, rate limits, or any side effects. The description lists returned fields but omits behavioral nuances beyond a simple retrieval.

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, front-loading the purpose and then summarizing the return content and argument. It avoids redundancy and presents information in a logical order, though the Args section could be slightly more integrated into the narrative.

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 presence of an output schema, the description need not detail all return fields, but it highlights key ones (metadata, provenance hash, compliance status, on-chain anchor). For a single-parameter read tool with an output schema, the description is reasonably complete, covering the purpose, argument semantics, and core result content.

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 value by clarifying that credential_id is a UUID and that it refers to the music credential, which the schema (type: string, no description) does not convey. This helps an agent understand the expected format and semantic meaning of the sole parameter, compensating for the 0% schema description 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 gets full provenance details for a music credential, specifying the resource and action. It does not explicitly differentiate from siblings like mt_verify_music_credential or mt_issue_music_credential, but 'provenance details' is specific enough for an agent to infer its distinct purpose.

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

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

The description implies usage when provenance details are needed but provides no explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives. It offers a clear context (retrieval of a credential's provenance) but lacks exclusions or routing to 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?

No annotations are provided, so the description carries the full burden. It discloses the score composition, the null/withheld condition based on endorser count, and special handling for seed agents. This gives the agent useful behavioral context beyond a bare 'get'. It does not explicitly state that the operation is read-only, but the verb 'Get' and lack of mutation hints make that reasonable.

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, with a brief two-sentence summary before the parameter documentation. It avoids fluff and stays focused. The structure is simple and front-loaded, though the parameter section could be more integrated rather than a separate 'Args' block. Still, it earns its keep.

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 an output schema present (though not shown), the description does not need to detail return fields. It covers the key conditions (null/withheld, seed handling) and the score composition, which are sufficient for calling the tool correctly. It leaves room for more detail about the output format, but the output schema presumably fills 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?

Schema coverage is 0%, so the description must compensate. It does provide a clear explanation of the 'did' parameter and an example value, which helps the agent form a valid DID. It could add format constraints or clarify that it is a string of a specific pattern, but the example covers the essential 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 states the action (Get) and the specific resource (Swarm Intelligence Trust Score for an agent), and includes a phase indicator. It is distinguishable from sibling name variants by the unique 'Swarm Intelligence' qualifier, though it does not explicitly name alternatives. This is clear but not as sharply differentiating as the get_calls example.

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 what the tool does and conditions that affect the result (null/withheld if fewer than 3 independent endorsers), but it does not explicitly state when to use this tool versus other scoring/trust tools in the sibling list (e.g., moltrust_score, moltrust_reputation, mt_get_swarm_graph). Usage context is implied but not explicitly contrasted with alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses badge validity (1 year) and auto-revocation on score drop, plus costs. However, it does not state whether the tool enforces the score thresholds before issuing, whether credits are deducted, or what side effects (e.g., on-chain/off-chain records) occur.

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 logically structured: purpose first, then behavioral details/options, then parameter explanations. It is mostly free of fluff, though tier values are repeated in the prose and Args section—minor redundancy that slightly reduces 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?

With an output schema present and only 2 simple parameters, the description covers the core invocation semantics: what the tool does, tier choices, costs, and validity. It is missing potential error/precondition guidance (e.g., insufficient credits, score not meeting threshold, duplicate badge prevention), but overall it is adequate for correct use.

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's Args section is essential. It explains 'did' as the agent's DID and 'tier' with explicit allowed values ('verified'/'trusted'), adding meaning far beyond the bare property names, defaults, and types.

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 'Issue a Verified by MolTrust badge for an agent,' which is a specific verb (issue) and resource (badge) with clear scope. The tool name and description uniquely identify this as a badge-issuing action, distinct from siblings like mt_check_badge, mt_get_badge, and moltrust_verify.

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: tiers with score thresholds and costs, validity period, and auto-revocation. It implies this tool is for issuing badges when an agent qualifies, but it does not explicitly contrast with alternatives such as moltrust_verify or mt_issue_music_credential, nor 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?

No annotations are provided, so the description carries the full burden. It does disclose that it creates a W3C Verifiable Credential, anchors on Base L2, and is EU AI Act compliant. However, it does not describe side effects (e.g., cost, storage, reversibility), failure modes, or permissions required. It gives some behavioral context 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 well-structured: a concise one-line summary followed by a brief explanation and a formatted Args list. The main purpose is front-loaded. The Args block is easy to scan and avoids unnecessary prose. It is appropriately sized for an 8-parameter tool.

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

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

Given the tool's complexity (8 params, 5 required) and lack of annotations, the description covers all parameters with examples, mentions the compliance context (EU AI Act) and anchoring (Base L2). It does not explain the return value, but an output schema exists, so that may be covered elsewhere. Overall, it provides sufficient context for an agent to call it correctly.

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

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

The description's Args section adds significant meaning beyond the input schema. It provides examples for each parameter (e.g., 'Suno API v3.2', 'true/false/partial' for human_oversight, 'CC-BY' for rights) and clarifies the format. Schema coverage is 0%, but the description compensates effectively, making parameter usage clear.

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

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

The description clearly states it 'Issue a VerifiedMusicCredential for an AI-generated music track' with a specific verb and resource. It also explains the purpose (provenance, rights, compliance) but does not explicitly differentiate from sibling issue tools like mt_shopping_issue_vc or mt_skill_issue_vc, though the domain (music) is 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 implies when to use it (to create a credential for a music track) but does not mention alternatives or exclusions. For example, it does not say 'use mt_verify_music_credential to verify' or provide context on when not to use this tool. The usage is implied by the verb 'Issue' and the domain, but not explicitly guided.

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 explains the ranking factors (win rate, ROI, volume, sample size, recency) and the limit parameter behavior (default 20, max 100), which is useful. However, it does not disclose whether the data is live, cached, paginated, or whether it requires authentication, leaving some behavioral gaps.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, the second explains the ranking criteria, and the Args section is minimal and directly tied to the schema. Every sentence earns its place with no 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?

For a simple read-only tool with one optional parameter and an output schema, the description is nearly complete. It covers what the tool returns (ranked wallets by composite score), the ranking factors, and the parameter semantics. The only missing context is whether the leaderboard is global or scoped, and any rate-limit or freshness caveats, but these are 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?

Schema description coverage is 0%, so the description must compensate. It does: it explains the 'limit' parameter's purpose, default value, and maximum. This adds meaning beyond the raw schema, which only shows a default of 20. The only minor gap is not explaining what happens if limit is exceeded (e.g., clamped or error).

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: 'Get the prediction market leaderboard — top wallets by prediction score.' It specifies the resource (prediction market leaderboard), the action (get), and the ranking criterion (composite prediction score). It also distinguishes itself from sibling tools like mt_prediction_link and mt_prediction_wallet by focusing on the leaderboard rather than linking or wallet details.

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 by explaining what the leaderboard ranks and the optional limit parameter, but it does not explicitly state when to use this tool versus alternatives or when not to use it. It provides no exclusions or alternative routing, so an agent must infer that this is the go-to for leaderboard data.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that it fetches trade history (external data access), calculates a score (computation), stores a profile (mutation), and optionally links a DID (side effect). It does not mention idempotency, permission requirements, or rate limits, but it covers the main behavior adequately. A small gap is the lack of detail on what happens on repeated calls (overwrite vs. update), but the core actions are transparent.

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

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

The description is concise and front-loaded: a two-sentence summary of the tool's purpose and process, followed by a structured argument list. Every sentence adds value—no fluff or repetition. The structure makes it easy for an agent to scan and extract key information quickly.

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 (fetching external data, computing a score, storing a profile, optional DID linking), the description covers all major steps and parameters. The output schema is available separately, so return values are not needed in the description. Minor omissions like error handling or edge cases (e.g., invalid address format) are not critical for selection and invocation, but the description is still sufficient for correct usage.

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 entirely for parameter documentation. It does so thoroughly: address is described as a 0x-prefixed 42-character wallet address, platform has a default value and example, did is optional with a format example. This fully clarifies each parameter's purpose and constraints, exceeding the bare schema.

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

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

The description starts with a clear action: 'Link a prediction market wallet and sync its track record.' It then details the steps (fetch trade history, calculate score, store profile, optionally link DID). This is specific and distinguishes it from siblings like mt_prediction_wallet (likely read-only) or mt_prediction_leaderboard (aggregated stats). The verb-resource pairing is explicit 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 implies its use case: linking a wallet to create a prediction score profile, with optional DID linking. It doesn't explicitly state when not to use it or name alternatives, but the platform parameter and optional DID suggest flexibility. The context of 'sync its track record' hints at an initial setup or update action, which is enough for an agent to decide. It could be improved by explicitly contrasting with related tools, but the purpose is clear.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does state the returned fields but does not mention side effects, rate limits, authentication needs, or whether the operation is read-only. Although 'Get' implies a read, this is not explicit, and there is no mention of error conditions or what happens for invalid addresses. The description is too thin 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?

The description is concise and front-loaded: the first sentence states the purpose, the second lists return fields, and the Args section is a clean bullet. There is no fluff or redundancy, and 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 an output schema, the description is fairly complete. It lists the key return fields and specifies the address format. However, it does not mention prerequisites (e.g., whether the address must already exist in the system) or error behavior, which would be useful. The presence of an output schema covers return structure, so this is a minor 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 has 0% description coverage for the address parameter, so the description must compensate. It does by specifying 'Prediction market wallet address (0x-prefixed, 42 chars)', providing both format and length. This adds meaningful validation context beyond the schema's type-only definition, though it could go further (e.g., mainnet vs testnet, checksum 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 gets a prediction market profile and track record for a wallet, with a specific verb (Get) and resource (wallet profile). It lists the returned fields (score, win/loss, volume, ROI, breakdown, events), which distinguishes it from siblings like mt_prediction_leaderboard and mt_prediction_link. The purpose is unambiguous and 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 provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or scenarios where another tool would be more appropriate. The only context is the purpose itself, which is implied but not explicitly contrasted with 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?

No annotations are provided, so the description carries the full burden. It discloses that the operation is admin-only and requires an admin key, which is a key behavioral trait. However, it does not mention side effects, reversibility, idempotency, or error conditions. For a mutation tool with no annotation coverage, this is a minimal but acceptable disclosure.

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

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

The description is succinct and well-structured: a one-sentence purpose statement followed by a clear Args list. Every sentence provides necessary information without redundancy. The admin requirement and the purpose are front-loaded, making it easy for an agent to quickly grasp the tool's use.

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 purpose, admin authorization, and parameter semantics. An output schema exists (as noted in context), so return values are not the description's responsibility. The description is complete for an agent to call the tool correctly, though it could optionally mention potential errors or prerequisites beyond the admin key, such as whether the DID must already exist.

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%, but the description provides detailed parameter semantics in the Args section. It explains each parameter (did, label, base_score, admin_key) with clear definitions, including the range for base_score (0-100) and its default (80), and the default for admin_key. This fully compensates for the missing schema descriptions.

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 'Register' and the resource 'trusted seed agent in the Swarm Intelligence network', and explicitly notes 'admin only'. It distinguishes this tool from siblings by specifying that seed agents bootstrap the trust network, which is a unique purpose among the many register-type 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 provides clear context: it is for registering seed agents, and it explicitly states 'admin only' and 'Requires the ADMIN_KEY for authorization'. It does not explicitly compare to alternatives or state when not to use it, but the purpose is specific enough that an agent would not confuse it with other register 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?

No annotations are present, so the description carries the behavioral burden. It clearly reveals that the operation creates a brand identity, produces a DID and API key, and explains the API key's downstream role in product registration and reseller authorization. It does not mention duplication behavior, irreversibility, or caller permissions, but the core side effect is well disclosed.

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

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

The description is compact and front-loaded with the purpose in the first line, followed by a short behavioral note and a structured Args block. The slight redundancy between 'Register a brand' and 'Creates a new brand identity' is minor because the second adds DID/API key detail.

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

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

For a simple three-string tool with an output schema, the description covers purpose, the main side effect, and every parameter. It leaves out when-not-to-use and failure/duplicate behavior, but an agent has enough information to make a correct first call.

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

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

The schema has 0% description coverage, but the Args block documents all three parameters with realistic examples and marks contact_email as optional. This compensates for the schema gap, though it omits format constraints or validation rules.

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 ('Register a brand with MT Salesguard') and names the created artifacts (DID and API key), so an agent can tell what the tool does. It does not explicitly contrast with siblings like mt_salesguard_reseller or mt_salesguard_verify, so it stops short of a 5.

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

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

The intended use is implied: call this when a brand needs to be registered. However, there is no explicit guidance on when not to use it or which sibling tool should be chosen for adjacent flows such as reseller authorization or verification.

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 mention the return values (authorization status, brand info, authorized SKUs, and expiry), which gives some transparency. However, it does not disclose whether the operation is read-only, whether any side effects occur, or whether specific permissions are required. The 'Verify' and 'Checks' wording implies a read operation, but this is not stated explicitly.

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 efficient: two sentences conveying purpose and return value, plus an Args line that explains the parameter. The key purpose is front-loaded, and there is no wasted verbiage. It is appropriately sized for a single-parameter verification tool.

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

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

The tool is simple (one parameter) and has an output schema, so the description does not need to enumerate return fields in detail. It covers the core purpose, parameter meaning, and return summary. However, it omits error conditions (e.g., what happens if the DID is invalid or not found) and does not mention any permissions or prerequisites. These are minor gaps 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 input schema only defines a string with title 'Reseller Did', but the description adds meaning by explaining it as a 'Reseller DID' and providing an example ('did:web:sneakerstore.com'). This goes beyond the schema and clarifies the expected format. While it could include more constraints (e.g., valid DID patterns), the example is valuable. Given the parameter is simple and well-explained, 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 a specific verb ('Verify') and resource ('reseller authorization'), and explains what it checks (whether a reseller DID is authorized by a brand to sell specific products). However, it does not explicitly differentiate from the sibling tool mt_salesguard_verify, which likely has a similar purpose, so it loses one point for lacking direct 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 no guidance on when to use this tool versus alternatives. It does not mention any conditions that would favor this tool over mt_salesguard_verify or others, nor does it provide any exclusions. The only contextual clue is the tool's name and the 'verify' verb, which implies usage but is not explicit.

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

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

With no annotations provided, the description must carry the full behavioral burden. It discloses what the tool returns (brand info, credential hash, Base anchor, risk level), which is useful, but it does not explain side effects, failure modes, or whether it performs external lookups. It also doesn't state that it is a read-only operation, though that is implied by 'verify'. This is adequate 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?

The description is concise and front-loaded with the purpose. The opening sentence states the function, followed by a brief explanation and parameter details. The example is useful and not redundant. However, the first two sentences are slightly repetitive ('Verify product provenance' and 'Checks whether a product ID has a valid...'), which could be tightened, but it's not verbose overall.

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 verify tool with one parameter and an existing output schema, the description covers the input and the key return values. It lacks usage guidance and behavioral details like error handling or prerequisites. Given the large sibling family, more differentiation would improve completeness, but for its simplicity it is minimally adequate.

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 provides a clear parameter description with an example format ('AIRMAX-90-WHITE-43'), which adds meaning beyond the bare 'Product Id' string type. This helps the agent construct valid inputs, though it doesn't specify constraints like length or allowed characters.

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 action ('Verify product provenance') and the resource ('MT Salesguard'). It further specifies what it checks (a valid ProductProvenanceCredential) and lists return fields, making the tool's purpose unmistakable. The example product ID adds concreteness. It distinguishes itself from generic verify tools by its focus on product provenance.

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 use when you need to verify a product's provenance credential, but it does not explicitly state when to use this tool over siblings like moltguard_credential_verify or mt_shopping_verify. There is no mention of alternatives or exclusions, leaving the agent to infer the appropriate context. The example clarifies the input format but not the selection criteria.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states that the tool 'Returns the MT Shopping service info including version, supported endpoints, BuyerAgentCredential schema, and verification details,' which discloses the core behavioral output. It does not mention side effects or auth requirements, but 'Get' and 'Returns' strongly imply a safe, read-only operation, making this adequately transparent for a 0-parameter info endpoint.

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

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

Two sentences with no wasted words. The main purpose is front-loaded, and the second sentence adds useful specifics about the response contents without being 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?

For a simple info tool with no parameters and an output schema present, the description is sufficiently complete. It states what the tool does and what the response includes, and the output schema covers the detailed return structure. No critical information for calling the tool 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?

The tool has zero parameters and the input schema is empty, so the schema coverage is trivially 100%. The description correctly does not add parameter details, and the baseline for a no-parameter tool is 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 verb ('Get') and the resource ('MT Shopping API information'), and lists the included contents. It does not explicitly distinguish from sibling tools like mt_shopping_verify or mt_shopping_issue_vc, but the purpose is specific and unambiguous enough that an agent can tell this is the metadata/info 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 description provides no guidance on when to use this tool versus alternatives. It does not say 'use this before issuing credentials' or point to sibling tools for verification actions. The usage is only implied by the name and description, which is not explicit enough for a dimension that asks for when/when-not guidance.

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

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

With no annotations, the description carries the full burden. It discloses that the tool creates a signed credential, which is the primary behavior, and notes enforced spend limits. However, it does not mention permissions required to issue, reversibility, or failure modes (e.g., invalid DIDs), which would be expected for a mutating credential-issuance operation.

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

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

The description is efficiently structured: a two-sentence purpose statement followed by a compact argument list. Every sentence adds value, and the format is scannable and front-loaded with the core purpose. No redundant filler or repetition of schema defaults beyond what is useful.

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 an output schema and no nested objects, the description covers the essential behavior and all parameters. It lacks explicit discussion of authorization/preconditions and does not clarify how this tool relates to the other shopping tools (mt_shopping_info, mt_shopping_verify), but the overall meaning is clear enough for an agent to call it correctly in the intended scenario.

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 fully compensate. It provides a dedicated Args section with human-readable explanations and examples for all six parameters, including units (spend_limit, currency), semantics (categories, validity_days), and DID formats. This adds substantial meaning beyond the bare schema titles.

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 (BuyerAgentCredential) and a specific action (issue/creates a W3C Verifiable Credential), and states the domain (shopping agent) that differentiates it from other issue_vc siblings like mt_skill_issue_vc and mt_travel_issue_vc. It clearly distinguishes this issuance tool from verification or info tools in the same family.

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

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

The description provides clear context for when it is used: to authorize a shopping agent to make purchases on behalf of a human with spend limits. It does not explicitly name alternatives or state when not to use it, but the purpose is specific enough to infer it should be used only for issuing shopping credentials rather than verifying or querying 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does so by enumerating the specific checks (credential signature, spend limits, trust score) and stating that it returns a verification receipt with approval status. It doesn't mention side effects or failure modes, but for a verification tool this is acceptable. The description adds useful detail 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?

The description is well-structured: a one-line summary, a bullet list of checks, then the Args block. It is concise without unnecessary fluff. The only minor inefficiency is the Args block repeating the parameter names already in the schema, but it adds needed context, so it's 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?

The description covers the core purpose, the checks, and all parameters. It mentions the return type (verification receipt with approval status) without elaborating since an output schema exists. It doesn't address error handling or prerequisites, but for a verification tool with a defined schema, this is sufficient. An agent has enough to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. The Args section provides meaningful explanations for all five parameters, including examples (e.g., '189.99' for amount, 'USDC' for currency). This goes beyond the schema's bare type/title and helps an agent construct correct 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 states a clear, specific action: 'Verify a shopping transaction against a BuyerAgentCredential.' It names the resource (BuyerAgentCredential) and the context (shopping transaction), and lists the checks performed (signature, spend limits, trust score). This distinguishes it from other verify siblings like mt_skill_verify or mt_travel_verify, which target different 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 implies when to use it: whenever a shopping transaction needs verification against a credential. However, it does not explicitly state exclusions or point to alternatives among the many sibling tools. For example, it doesn't say 'use mt_shopping_info for non-verification queries' or 'use moltrust_verify for general trust verification.' The guidance is adequate but not explicit.

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

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

No annotations are provided, so the description carries the full burden. It clearly discloses that it fetches SKILL.md from a URL, computes a canonical SHA-256 hash, runs an 8-point audit, and starts scoring at 100. It does not mention caveats like non-public URL failures or side effects of the fetch, but the core behavior is transparent.

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

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

The description is compact, purpose-first, and free of filler. Each sentence adds value: the audit scope, scoring method, threshold, and URL format are all covered without redundancy.

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

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

With one simple parameter and an output schema present, the description covers the tool's purpose, process, and input format adequately. It could add explicit guidance on when to prefer this over sibling tools, but that gap is already reflected in the usage dimension.

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 for the single parameter, and it does: it specifies that github_url must be a GitHub repo or a direct HTTPS link to SKILL.md. This provides the format and constraint that the schema lacks.

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 ('Audit'), a clear resource ('AI agent skill (SKILL.md)'), and the security-risk focus. It also adds an 8-point audit and passing score, which differentiates it from sibling verification tools like mt_skill_verify and mt_skill_issue_vc.

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

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

Usage is implied: call this to assess a skill URL for security risks. However, the description never explicitly names alternatives, when not to use it, or how it compares to related auditing/verification tools, leaving some selection burden on 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?

With no annotations provided, the description carries the full burden of behavioral disclosure and does substantial work. It reveals that the tool fetches external content, runs a security audit, conditionally issues a W3C VC using Ed25519, and may require a $5 USDC payment via x402. It could add failure behavior or what happens when score < 70, but it discloses the most operationally critical traits.

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 efficiently structured: a one-line summary, then a compact workflow explanation, then an Args list. Every sentence provides useful information without padding. The most important trigger conditions and the payment caveat are disclosed early.

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

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

For a tool with no annotations, no schema descriptions, and an output schema present, the description covers the core semantics, parameters, payment, and cryptographic format. It omits some edge details like the exact response contents or error behavior for score < 70, but these are secondary given the output schema and the level of detail already 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?

Schema description coverage is 0%, so the description must compensate. It does by explaining author_did as 'DID of the skill author' with an example, and repository_url as 'URL to the skill repository or SKILL.md'. These meanings are absent from the schema's bare string types, giving the agent enough to supply correct values.

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 specific action: issuing a VerifiedSkillCredential for an AI agent skill. It goes beyond a simple label by describing the workflow (fetch SKILL.md, run security audit, issue if score >= 70), which distinguishes it from siblings like mt_skill_audit and mt_skill_verify.

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

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

The description provides clear context for when to use the tool: to issue a credential after an audit passes a 70-score threshold, with a payment requirement when a paywall is active. It does not explicitly name when-not-to-use alternatives, but the workflow makes the intended use case clear relative to audit/verify siblings.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool checks credential issuance and returns credential details if verified, which is useful. However, it does not describe what happens when the hash is not verified (e.g., error vs. empty result), whether any side effects occur, or any rate limits. For a read-only verification tool, this is adequate 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?

The description is compact and front-loaded with the core purpose in the first sentence. The Args section is minimal and useful. It earns its place without fluff, though the second sentence ('Checks if a VerifiedSkillCredential has been issued') is slightly redundant with the first.

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 has one parameter, no annotations, and an output schema exists. The description covers the input and the basic behavior, but it doesn't describe the output structure or what 'credential details' means. Since an output schema exists, the return format is presumably structured, but the description could still clarify the verification outcome semantics (e.g., what a non-verified hash returns). Adequate for a simple tool 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?

Schema description coverage is 0%, so the description must compensate. It does explain the skill_hash parameter with an example format ('sha256:a1b2c3...'), which adds value beyond the schema's bare string type. However, it doesn't specify the exact format requirements (e.g., length, allowed characters) or whether the 'sha256:' prefix is mandatory. The single parameter is reasonably documented but could be more precise.

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 verifies an AI agent skill by its canonical SHA-256 hash and checks whether a VerifiedSkillCredential has been issued. It distinguishes itself from sibling tools like mt_skill_issue_vc and mt_skill_audit by focusing on verification, though it doesn't explicitly name those alternatives.

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

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

The description implies usage: call this when you have a skill hash and need to check if a credential was issued. It does not explicitly state when to use this over siblings like mt_skill_audit or moltproof_verify, nor does it mention any prerequisites or exclusions. The context is clear enough for a simple verification tool but lacks explicit routing guidance.

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

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

With no annotations provided, the description must carry the behavioral transparency burden. It does state that the tool returns service description, supported segments, and API endpoints, making it clear this is an informational read. It does not explicitly confirm the absence of side effects, mention authentication requirements, or describe rate limits, but for a zero-parameter info endpoint this is a reasonable level of disclosure.

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

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

The description is two concise sentences with no filler. The primary purpose is front-loaded in the first sentence, and the second sentence adds exactly the detail needed about the return 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?

For a zero-parameter discovery tool with an output schema present, the description is complete. It tells the agent what the tool does, what it returns, and which domain it belongs to, so the agent can decide to call it and know what to expect.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter meaning because there are no inputs to document and the schema already covers everything.

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 and resource: 'Get MT Travel service information and available endpoints.' It further clarifies the scope by listing what is returned: service description, supported segments, and API endpoints. This clearly distinguishes it from action-oriented siblings like mt_travel_issue_vc and mt_travel_verify.

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 service-discovery tool that should be called to obtain service information and endpoint details before interacting with the MT Travel booking trust protocol. However, it does not explicitly state when to use it versus alternative tools, nor does it mention 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 provided, the description carries the full burden. It discloses that it creates a cryptographically signed credential with enforced segment permissions and spend limits, which is the core behavior. However, it does not mention prerequisites (e.g., whether the principal must be authenticated), side effects like persistence or costs, or failure modes. The description is not contradictory but lacks depth beyond the basic action.

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 well-structured: a two-sentence summary followed by an Args list. It is front-loaded with the purpose, and each parameter explanation is concise and informative. While it is longer than the bare minimum, the length is justified because it compensates for the sparse schema. There is minimal redundancy.

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

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

Given the presence of an output schema, the description does not need to detail return values. It covers all 7 parameters with clear explanations and defaults. However, it omits important context such as authentication requirements, whether the caller must be the principal, or any side effects like credential storage. For a credential-issuing tool, this is a notable gap, but the core functionality is adequately explained.

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 provides only parameter names and types (0% description coverage). The description fully compensates by explaining each parameter with examples and defaults: agent_did is 'DID of the travel agent (e.g. "did:base:0x...")', spend_limit is 'Maximum spend amount per booking', validity_days has a default of 30, etc. This adds essential meaning that the schema lacks, making parameter usage clear.

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

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

The description clearly states it 'Issue a TravelAgentCredential (W3C Verifiable Credential)' – a specific verb and resource. It further explains the purpose: authorizing an AI agent to book travel with enforced permissions and spend limits. This distinguishes it from sibling verify tools like mt_travel_verify and other issue tools like mt_shopping_issue_vc.

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 (issue a credential for a booking agent) but does not explicitly state when to use it versus alternatives, nor does it mention exclusions. There is no reference to sibling tools like mt_travel_verify or mt_travel_info, leaving the agent to infer context. This is implied usage, not 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses the exact 10-step pipeline (signature, expiry, DID match, etc.), which is rich behavioral detail. It does not explicitly state read-only status or side effects, but the verification nature implies safety. The pipeline description adds significant value beyond a generic 'verify'.

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 structured with a summary line, a pipeline list, and an Args block. The pipeline list is slightly verbose but each item adds behavioral context. It is front-loaded with the purpose. A minor trim could be made, but it remains 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?

The description covers purpose, steps, and all parameters. It does not describe return values, but an output schema exists, which is acceptable. For a 6-param verification tool with no annotations, this is nearly complete. Missing explicit side-effect disclosure is a minor 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 0%, so the description must compensate. It does so thoroughly: every one of the 6 parameters is described with context and examples (e.g., agent_did format, segment enum values, currency code). This is exactly what an agent needs to correctly populate arguments.

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