MolTrust MCP Server

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

With no annotations, the description carries the full behavioral burden and does so: auth requirement (X-API-Key header, free key signup URL), cost implication ('counts against your plan like any check'), and the critical fail-closed rule that values the check cannot derive count as unknown and end in forbid. It also states a refusal policy for Amazon credentials, which is exactly the kind of non-obvious context an agent needs.

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 decision semantics are front-loaded in the first sentence, and the Args block is terse and each line earns its place. The signup URL and the indented docstring layout add slight visual noise, but nothing is redundant prose.

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?

An output schema exists, so return values need not be described. What an agent must know before calling is present: required inputs, auth mechanism, billing, credential refusal, and the fail-closed rule for under-specified context. Nothing material is missing for a pre-flight policy check.

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

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

Schema coverage is 0% and the schema gives bare types only, yet the description documents all four parameters: profile (the object from ads_mandate_template), tool (with a concrete example name), arguments (exactly as the agent would send them), and context (with the expected shape and units — campaigns {id: {brand, daily_budget(cents)}}, account_daily_total(cents)). This fully compensates for the undocumented schema and explains the unknown→forbid consequence of incomplete context.

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

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

The first line states a specific verb-and-object: adjudicating Allow/hold/forbid for one intended Amazon Ads MCP tool call before execution. It is clearly distinguishable from sibling ads_mandate_template (which produces the profile this tool consumes) and from unrelated moltrust_* checks. An agent can tell what this returns (a decision) and when it is invoked (pre-flight).

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 timing is explicit ('before it runs') and prerequisites are named: the MolTrust API key must ride as the X-API-Key header, obtainable via a signup POST. It does not explicitly state when NOT to use it or name a competing alternative beyond referencing ads_mandate_template for the profile, so it stops short of full 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, the description carries the full burden and does disclose a key behavioral trait: 'Pure: nothing is stored.' It also explains enforcement consequences ('valid_until ... after it every call is forbidden'; budget caps mean 'forbid'; hold threshold requires a named approver). It does not cover failure modes or whether signing credentials are mandatory, keeping it below a 5.

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

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

Purpose and purity lead, returns follow, and the parameter list closes — a sensible front-loaded order. The block is long, but with 0% schema coverage the Args enumeration is largely load-bearing rather than padding.

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 15-parameter tool with no annotations, the description covers purpose, side-effect profile, outputs, and every parameter, and an output schema exists so return-shape detail is not required. It stops short of describing authentication requirements (implied by principal_did/principal_public_key) or error behavior.

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

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

Schema description coverage is 0%, so the description must supply all parameter meaning, and it documents every one of the 15 args with units and semantics the schema lacks (USD caps, percent for max_bid_change_percent, RFC 3339 UTC for validity dates, enforcement behavior for caps and hold thresholds). It adds genuine meaning rather than restating field names.

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 opening sentence names a specific verb and compound resource: 'Build an ads profile and its AAE mandate for one or more Amazon Ads accounts.' It also scopes the operation ('for one or more accounts') and distinguishes itself from siblings by naming ads_check and ads_onboard as the downstream/upstream counterparts.

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 establishes the workflow context clearly: the returned `profile` is 'pass[ed] to ads_check' and `mandate` is 'what /enforce/check evaluates', and the `tools` default references what is 'documented in ads_onboard'. It never states an explicit when-not-to-use or a hard exclusion, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It discloses that no input and no account are required, which is useful for an authentication-sensitive domain. However, it does not describe whether the operation is read-only, what its output contains (despite an output schema), or any other behavioral traits like rate limits or side effects.

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

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

The description is three short sentences with no wasted words. The first sentence is slightly awkwardly phrased as a title-like clause followed by a list, but the key constraint 'No input, no account needed' is front-loaded after the content summary.

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

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

Given the simplicity (zero params, output schema exists), the description is nearly complete: it explains the purpose, the covered topics, and the lack of prerequisites. It could be stronger by stating when this tool should be invoked relative to siblings, but the essential information for an agent to call it is present.

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

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

The tool takes zero parameters, so the baseline is 4. The description adds the explicit confirmation 'No input, no account needed,' which aligns with the schema and reassures the agent about the call requirements.

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 tool's purpose as onboarding for MolTrust Ads and lists the concrete content covered: verdicts, plans, key sign-up, SDK, and endpoints. It does not explicitly differentiate itself from siblings like ads_check or moltguard_credential_issue, but the onboarding focus is clear enough for an agent to understand its role.

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

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

The only usage hint is 'No input, no account needed,' which tells the agent it can call it without prerequisites. There is no guidance on when to use this tool versus alternatives such as ads_check or the moltguard tools, nor any indication that it should be called first in a workflow.

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

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

No annotations exist, so the description carries the full burden and does well: ordering (newest first), the signing/verification model (each event signed by MolTrust and independently re-verifiable offline via moltrust-verify against GET /canary/trust-list), pagination semantics, and the API-key auth requirement. It does not state error or rate-limit behavior, keeping it just short of a 5.

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

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

Front-loads the most important facts (what the events are, ordering, authenticity model) before the Args block. The Args list partially restates signature-level info, but since the schema has no descriptions those lines earn their place; still slightly padded.

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

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

An output schema exists, so return-shape detail is unnecessary, and the description covers auth, ordering, verification path, and all three parameters. It leaves out failure modes (invalid canary_id, offset past the end) but is otherwise sufficient to call 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?

With 0% schema description coverage the description must carry all three parameters, and it does: canary_id is scoped to one canary and sourced from canary_issue/canary_list, limit is page size capped at 200, offset is the page start. It adds real meaning the bare schema does not, though it could specify units or behavior for out-of-range 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?

States a specific verb+resource ('Your leak events, newest first') plus the defining traits: MolTrust-signed and carrying AER material. It names related siblings (canary_issue, canary_list, moltrust-verify) so an agent can place it in the workflow, though it never explicitly contrasts it with canary_list or molcheck_evidence as the alternative source of related 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?

It gives real operating conditions — scope it to one canary optionally, page size capped at 200, and the X-API-Key auth requirement on the MCP connection — but never says when to reach for this tool versus canary_list or the molcheck_*/moltrust_verify siblings. Usage context is implied rather than routed.

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

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

With no annotations, the description carries the full behavioral burden and does so richly: it states the leak-detection effect and signed leak event, the cost ('costs what a credential costs'), the authentication requirement (X-API-Key header), and the side effect of 'hold' mode putting the counterparty on hold. This is well beyond what a bare schema provides.

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

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

The purpose is front-loaded in the first sentence, and the structured Args section is easy to scan. There is minor redundancy ('for one counterparty: a credential to hand to that counterparty') and some verbosity, but the length is reasonable for the concept's complexity.

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 a novel concept, zero schema descriptions, no annotations, and an output schema that handles return values, the description is complete enough to call the tool correctly. It covers prerequisites, all parameters, authentication, cost, and the leak-event outcome.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: counterparty_did is a registered unrevoked MolTrust agent DID, mode is explained as 'bound' vs 'decoy' with distinct presentation semantics, on_leak is explained as 'hold' vs 'none' with an endpoint reference, and credential_type is tied to the credential issuance model.

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

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

States a specific verb and resource: 'Issue a leak canary for one counterparty: a credential to hand to that counterparty.' It clearly defines what a leak canary is and its effect. However, it does not explicitly distinguish itself from sibling tools like canary_list or canary_events, so sibling differentiation is only implied by the 'issue' action.

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

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

The description explains the purpose and prerequisites (API key, counterparty must be registered and unrevoked), which implies when the tool is useful. But it offers no explicit when-to-use guidance, no alternatives, and no exclusions relative to sibling tools like canary_list or canary_events.

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

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

With no annotations present, the description carries the full burden and does meaningful work: newest-first ordering, limit/offset pagination, the next_offset-null end-of-page sentinel, and the X-API-Key auth requirement on the MCP connection are all disclosed. What it omits is rate limiting, page-size bounds, and an explicit read-only statement, so it falls short of fully covering behavior.

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

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

Three short sentences, front-loaded with what the tool returns, followed by pagination mechanics and the auth prerequisite. No filler, and the most decision-relevant information leads.

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 two-parameter, zero-required list tool with an output schema, the description covers fields, ordering, pagination, and auth — enough to invoke it correctly. Only the missing sibling routing and explicit read-only framing keep it from being 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?

Schema description coverage is 0% and neither parameter has a description, so the description must compensate. It names limit and offset and ties them to pagination, and mentions the next_offset sentinel on the response side, but gives no valid ranges or units beyond the schema 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?

States a clear resource (leak canaries) and enumerates the returned fields (counterparty, mode, reaction on leak, event count), so an agent knows exactly what comes back. It does not explicitly distinguish itself from the nearby siblings canary_events and canary_issue, so differentiation is left to the reader.

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

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

There is no explicit when-to-use or when-not guidance and no named alternative, even though canary_events and canary_issue sit right next to it. 'Your leak canaries' weakly implies listing one's own canaries, but routing between the three canary tools is left entirely to inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose 'Read-only', which is the key trait an agent needs for a query tool, but it says nothing about auth requirements, rate limits, or scoping. Since an output schema exists, the return shape is partly covered elsewhere.

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

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

Front-loads the key output description in the first sentence, with the read-only note immediately after. The leftover docstring-style 'Args:' block is slightly noisy but very short and carries the only parameter meaning available.

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

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

For a single-parameter read tool with an output schema, the definition covers what is returned, the read-only nature, and the identifier format. The notable gap is routing guidance among the many molcheck/moltproof/moltrust siblings, which is what keeps it from being complete.

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

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

Schema coverage is 0% and the schema only gives a bare string titled 'Agent', so the description must compensate. It does: 'public agent identifier (address / DID / ERC-8004 ref)' clarifies that the value is public and enumerates three accepted identifier forms, which is meaningful added semantics.

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

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

States a concrete verb-less but specific output: a verdict plus the decoded transactions that breached the mandate. An agent can infer this is an evidence-retrieval tool, though it does not explicitly contrast itself with the sibling molcheck_verdict, which likely returns the verdict alone.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as molcheck_verdict or molcheck_verify despite a large family of near-identical sibling tools. The only context offered is 'Read-only.'

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

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

No annotations are provided, so the description carries the full burden. It usefully declares 'Read-only', which is the key safety signal, but omits auth requirements, whether a missing mandate errors, and any caching or rate-limit behavior.

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

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

Front-loaded with the resource and its fields, then the read-only flag, then the arg. The docstring formatting is somewhat noisy but every line carries 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?

An output schema exists so return values needn't be described, and the single parameter and read-only nature are covered. The only real gap is routing guidance against the many sibling mandate/verify tools.

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

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

Schema description coverage is 0% and the schema only says type string, so the description does the compensating work by defining agent as a 'public agent identifier (address / DID / ERC-8004 ref)'. That materially clarifies the expected identifier format.

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

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

States a specific resource (the committed AAE mandate) and enumerates its content (venues, position cap, validity), so an agent knows what it will get. It lacks a clear verb and, crucially, does not distinguish itself from sibling mandate tools like moltproof_mandate or ads_mandate_template.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternative mandate-related siblings. The only context offered is 'Read-only', which is a constraint rather than usage direction.

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

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

With no annotations provided, the description carries the full disclosure burden. It does contribute two real traits - it is read-only and it sorts NO_MANDATE/NEEDS_REVIEW entries lower - but it says nothing about auth requirements, pagination, or completeness of the listing.

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

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

Two short sentences with the resource description front-loaded and no filler. The fragmentary style is slightly terse for a domain-specific term like 'committed mandates', but nothing is wasted.

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

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

An output schema exists so return shape need not be explained, and there are no parameters to document. However, the description does not clarify the domain terms or how this registry relates to its moltproof_registry sibling, leaving ambiguity about which registry tool to 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 tool takes zero parameters, so there is nothing for the description to disambiguate; the schema is also fully covered. Baseline of 4 applies since no parameter semantics are needed.

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

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

The description names a specific resource: agents with committed mandates and their current verdict, ranked by mandate status. That is clear enough to know what is returned, but the verb is implicit (list/query) and there is no differentiation from the sibling moltproof_registry, which appears to cover similar ground.

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

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

It states 'Read-only' and a ranking preference ('Ranks NO_MANDATE / NEEDS_REVIEW lower'), but gives no guidance on when to reach for this tool versus molcheck_mandate, molcheck_verdict, or moltproof_registry. Usage is only implied by the returned content.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the operation is 'Read-only' and 'Recomputable from public chain data + the public mandate,' implying deterministic, no-secret-state behavior. It does not, however, cover error/permission cases or what happens if no mandate is committed, leaving real gaps for a verification 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 definition is front-loaded with the purpose, then the read-only/recomputability note, then the Args block. Every line earns its place and there is no filler. It is terse but appropriately sized for a single-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?

An output schema exists, so return values need not be explained, and the one input parameter is fully described. The read-only and recomputable claims give adequate behavioral context. The main shortfall is the lack of routing guidance against the many verification siblings, but for a simple one-arg read tool this is close to complete.

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

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

Schema description coverage is 0% and the single 'agent' parameter has no schema description, so the description must compensate. It does so well by enumerating accepted identifier formats: agent address, did:moltrust / did:web, or ERC-8004 reference, and noting the value is public. This adds substantial meaning beyond the bare 'string' 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 states a specific verb+resource: it returns a 'Verdict + per-check breakdown for an agent against its committed mandate.' This is far more concrete than a bare name restatement and clearly conveys what the tool produces. It does not explicitly distinguish itself from close siblings like molcheck_verify, molcheck_evidence, or moltproof_verdict, 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?

There is no explicit when-to-use or when-not-to-use guidance, and no named alternative among the many molcheck_*/moltproof_* siblings. The mention of 'public chain data + the public mandate' hints at the context but does not tell the agent when verdict is the right call versus verify or evidence.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose two useful traits: it is read-only and performs no remote fetching. It does not say whether a failed signature check raises an error or returns a negative result, nor how expensive/authoritative the recomputation is. Adequate but incomplete for an unannotated tool.

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

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

The lead sentence states the action, the second states the operating constraint, and the Args block documents each parameter. Front-loaded and free of filler, though the docstring-style indentation is slightly awkward for a tool description.

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

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

An output schema exists, so return values need not be explained, and the offline/read-only note covers the main environmental concern. Given four parameters with nested objects and zero schema description coverage, an agent still lacks detail on the expected shape of the mandate and action objects, which is the main 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% and there are four parameters including nested objects, so the description must compensate, and it largely does: agent is 'public agent identifier', mandate is 'the public AAE Verifiable Credential', actions are 'public, already-decoded on-chain actions', and signature is 'optional prior MolCheck signature to check'. The 'already-decoded' qualifier is genuinely useful input-shape guidance, though the expected internal structure of mandate/actions remains unspecified.

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

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

States a specific verb and resource: recompute a verdict from public inputs and check its signature. It is clearly distinguishable from molcheck_verdict (produce a verdict) and from the moltproof_verify sibling family. It does not, however, explicitly contrast itself with those siblings in the text.

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

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

The description gives a real usage constraint ('Offline and read-only: no DID/mandate/context is fetched here'), which tells the agent this is a self-contained check rather than a live lookup. It stops short of saying when to choose this over molcheck_verdict or moltproof_verify, or what preconditions the caller must satisfy.

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 already declare readOnly=false, idempotent=false, destructive=true, and the description usefully adds what the credential contains and that it is JWS-signed. However, for a non-idempotent, destructive-flagged mutation it says nothing about what a repeat call does (new credential each time? overwrites/revokes the prior one?), whether it consumes credits, or whether signing keys are managed server-side.

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

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

The opening sentence front-loads purpose, followed by one dense sentence on payload and signature. The trailing 'Args:' block is fully redundant with the schema and is the one segment that does not earn 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?

An output schema exists, so return-shape explanation is correctly omitted, but the description stops short on the operational facts an agent needs before firing a destructive, non-idempotent write: re-issuance semantics, cost, and any prerequisite state on the wallet address.

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

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

Schema description coverage is 100% and there is a single required parameter, so the schema alone fully documents it; the description's Args block merely restates 'Base (EVM) wallet address (0x...)' verbatim. Baseline for a single fully-documented param is a 4, with no added semantics beyond the schema.

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

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

States a specific verb (issue) and resource (W3C Verifiable Credential / AgentTrustCredential) and enumerates the credential's payload (trust score, Sybil score, ERC-8004 status, MolTrust status) plus the signing scheme (Ed25519 JWS). It never names its natural counterpart moltguard_credential_verify or the other *_issue_vc siblings, so the boundary between issuance tools is left to the agent.

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

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

Usage is only implied by the verb: you issue a credential when you want one for a wallet. There is no explicit statement of when to prefer this over moltguard_credential_verify or the mt_*_issue_vc tools, and no preconditions (e.g., must the address be registered or scored first).

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 declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavior detail—Ed25519 signature check and payload return on success—but does not describe what happens on invalid signatures (error shape, exception, or null return), leaving a gap for a verification 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 short and front-loaded with the core action. The Args section duplicates the schema's own parameter description, which is minor waste, but overall it is efficiently 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?

For a single-parameter read-only verification tool with a 100%-covered schema and an output schema present, the description is nearly complete. The only meaningful omission is failure behavior, but return structure is presumably covered by the output schema.

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

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

Schema coverage is 100%, and the single parameter jws is fully documented in the schema. The description's Args line repeats the schema text verbatim without adding format, syntax, or validation details, so baseline 3 is appropriate.

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

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

The description states a specific verb (verify) and a precise resource (MoltGuard Verifiable Credential JWS signature), and adds that it checks the Ed25519 signature and returns the payload on success. This makes the operation clear, though it does not explicitly distinguish itself from the many other *_verify siblings beyond the MoltGuard naming.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as molcheck_verify, molproof_verify, or moltrust_verify. The description implies it is for verifying a MoltGuard credential but offers no conditions, exclusions, or prerequisites for selection.

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

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

readOnlyHint=true already covers the safety profile, and the description adds genuine value by disclosing the data sources it aggregates (Blockscout wallet history, ERC-8004 registration, MolTrust DID, Sybil indicators), which implies external calls and possible latency. It stops short of saying anything about caching, rate limits, or behavior when an address has no on-chain history.

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

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

Front-loaded: the one-line purpose comes first, followed by the return contents. Slightly redundant in restating the 'address' parameter that the schema already documents, but otherwise tight with no filler.

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

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

An output schema exists, so the return-value enumeration is a bonus rather than a necessity, and the read-only nature is covered by annotations. What is missing is the disambiguation from moltguard_score/moltguard_sybil and any note on failure or empty-result behavior for unregistered wallets — the main gaps for an agent choosing between near-identical tools.

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

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

Schema coverage is 100% and the single 'address' parameter is fully documented in the schema. The description's Args block repeats that same text verbatim (Base EVM address, 0x...), adding no format details, validation rules, or examples beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource: a detailed trust report for a Base wallet address, and enumerates the report's components (scoring breakdown, Blockscout history, ERC-8004, DID cross-reference, Sybil indicators). It does not, however, distinguish this from closely named siblings like moltguard_score or moltguard_sybil, so an agent cannot tell purely from the description which to pick.

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

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

There is no explicit when-to-use guidance and no mention of alternatives. Given siblings moltguard_score and moltguard_sybil cover overlapping ground, the absence of routing ('use this instead of X when you need the full aggregate') leaves selection ambiguous. Usage is only inferable from the word 'detailed'.

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 readOnlyHint annotation already establishes that this is a safe read operation. The description adds meaningful behavioral context beyond annotations: it scans the top 20 active Polymarket markets by 24h volume and returns only markets with anomaly indicators, sorted by anomaly score. It does not mention data freshness or rate limits, but that is acceptable given the annotation and output schema.

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

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

The description is two concise sentences, with the core purpose front-loaded before the scanning methodology. Every sentence adds useful information without waste.

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

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

For a no-parameter, read-only feed with an output schema, the description provides enough context to invoke it correctly: what universe is scanned, how markets are selected, what is returned, and how results are sorted. Safety is covered by annotations and return values by the output schema, so no material gap remains.

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. No parameter semantics need explanation, and the description correctly does not introduce any parameter-related confusion.

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: get the top anomaly feed for markets with the highest integrity concerns. It adds useful scope details (Polymarket markets, top 20 by 24h volume, anomaly indicators, sorted by anomaly score), but it does not explicitly differentiate itself from sibling tools such as moltguard_detail, moltguard_market, or moltguard_score.

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

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

The description implies when this feed is useful by framing it as the top anomaly overview, but it gives no explicit when-to-use vs when-not-to-use guidance and does not name alternatives. An agent can infer appropriate use, but routing to a sibling for detail or individual market inspection is left unstated.

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 already declare readOnlyHint=true, so safety is covered. The description adds genuine behavioral context by naming the four analysis dimensions used, but says nothing about cost, rate limits, or what happens when a market ID is unknown or illiquid.

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?

Purpose is front-loaded in the first sentence, with analysis detail immediately after. The trailing Args block duplicates schema content and is the only waste, but it is short.

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?

A single required parameter plus a read-only profile and an output schema means little more is needed; the analysis dimensions give the agent enough to trust the result. Only the behavior on invalid or thin markets is unaddressed.

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

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

Schema coverage is 100% and the description's 'Args:' line merely restates the schema's own text ('Polymarket market/condition ID') verbatim. No format example or accepted ID variant is added, so baseline 3 applies.

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

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

States a specific verb and resource ('Check a Polymarket prediction market for integrity anomalies') and enumerates the exact signals analyzed (volume spikes, price-volume divergence, liquidity ratios, outcome price spreads). This clearly separates it from the credential/registry/reputation siblings, though no sibling is named explicitly.

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

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

Usage is implied — you call it when you want to detect manipulation in a specific market — but there is no guidance on when to prefer it over near-domain neighbors like moltguard_score, moltguard_detail, or moltguard_sybil, nor any prerequisites or exclusions.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower; the description still adds real value by disclosing the scoring inputs (on-chain activity, ERC-8004 registration, USDC balance, counterparty diversity, MolTrust credentials) and the output range (0-100). It does not mention rate limits, caching, or behavior for unknown/ineligible addresses.

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

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

The core sentence is front-loaded and the scoring-signal inventory earns its place. The trailing Args block duplicates the input schema and is mild redundancy rather than 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?

With one parameter, an output schema, and read-only annotations, the structured fields carry most of the load and the description covers purpose, inputs analyzed, and score range. The main missing piece is how it relates to overlapping trust/reputation 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?

Schema coverage is 100% and there is a single required parameter, so the schema already documents the address format. The description's Args block merely restates the schema description verbatim, adding no new 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?

States a specific verb and resource ("Get an agent trust score") plus the target subject (Base wallet address), and enumerates the inputs to the score, so the agent knows exactly what the tool computes. It does not, however, distinguish itself from similar-sounding siblings like mt_get_trust_score or moltrust_reputation.

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

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

There is no explicit guidance on when to call this versus the many related scoring/reputation siblings in the server. Usage is only implied by the description of what is computed, with no exclusions or prerequisites stated.

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

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

readOnlyHint=true already tells the agent this is a safe, non-mutating scan. The description adds genuine beyond-schema context: it enumerates the heuristics applied and explains that funding-cluster tracing expands the check from a single wallet to the funder's outbound ETH graph, which is important for interpreting results as 'Sybil ring' evidence rather than a per-wallet verdict. Rate limits, latency, and external data sources are not mentioned, keeping it short of a 5.

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

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

The core purpose is front-loaded and the analysis list is compact and information-dense. The trailing 'Args:' block largely duplicates the input schema's own address description, which is the only redundant element in an otherwise well-structured definition.

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

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

For a one-parameter read-only scan with an output schema present, the description supplies enough: what it checks, how funding clusters extend the analysis, and the required input. It does not need to explain return values because the output schema carries that, and annotations cover the safety profile.

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

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

With a single parameter at 100% schema description coverage, the schema already documents the address fully. The description restates 'Base (EVM) wallet address (0x...)' without adding new constraints or format details, so it neither compensates nor detracts. Baseline 3 applies.

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

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

The opening sentence gives a specific verb and resource: 'Scan a Base wallet for Sybil indicators', followed by the concrete signals analyzed (wallet age, transaction patterns, counterparty diversity, funding source, funding clusters). It is clear and unambiguous, but it does not explicitly distinguish itself from nearby trust-scoring siblings like moltguard_score or moltguard_detail, leaving the agent to infer the Sybil-specific 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 only implied: an agent gathers that this tool should be called when Sybil risk needs checking. There is no explicit 'use this instead of X' routing against moltguard_score or moltguard_detail, and no prerequisites (e.g., whether the address must be on Base mainnet, whether a funded wallet is required).

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose 'Read-only' and indicates the response content (verdict plus decoded breaching transactions), which is useful. However, it omits auth/prerequisite requirements and any note on whether calling the deprecated alias still behaves identically to the replacement.

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 deprecation notice is front-loaded and the whole description is short, with only a small amount of leftover docstring formatting in the Args block. Every sentence carries information; nothing is padded.

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

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

An output schema exists, so return values need not be explained (though they partially are). With the deprecation routing, read-only disclosure, and parameter format guidance all present, the definition is nearly complete for a simple one-parameter read tool; only auth expectations are unaddressed.

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

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

Schema coverage is 0% and the schema documents 'agent' only as a bare string, so the description must compensate. It does: 'public agent identifier (address / DID / ERC-8004 ref)' gives concrete accepted formats that the schema lacks, which is meaningful guidance for the single required 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 states the tool is a deprecated alias of molcheck_evidence and summarizes its payload ('verdict plus the decoded transactions that breached the mandate'), which is specific about the resource returned. It distinguishes itself from the sibling molcheck_evidence by naming it directly. It loses a point only because its own purpose is defined entirely by reference to another tool rather than standing alone.

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

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

It explicitly says 'Deprecated alias of molcheck_evidence; use that name' — a direct when/when-not instruction that routes the agent to the correct alternative. There is no ambiguity about whether this tool should be selected.

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 supplied, the description carries the full behavioral burden and does disclose 'Read-only,' plus the semantic content of the returned mandate. It does not cover auth/permission requirements or failure modes, which is a gap, but the read-only declaration plus data-shape disclosure is meaningful context.

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

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

Front-loaded with the deprecation notice, followed by a one-line purpose and a short Args block. Efficient, though the docstring-style 'Args:' formatting is slightly verbose for a single parameter.

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?

An output schema exists, so return values need not be described, and the deprecation routing plus read-only note plus identifier formats cover what an agent needs to call this correctly. Minor omission of any auth or error context keeps it short of perfect.

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% for the single 'agent' parameter, so the description must compensate — and it does by defining the accepted identifier formats ('address / DID / ERC-8004 ref'), which is real value beyond the bare string type in the schema.

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

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

The description names the exact resource ('the committed AAE mandate for an agent') and enumerates its contents (venues, position cap, validity), so the agent knows precisely what it retrieves. It also explicitly identifies itself as a deprecated alias and points to the replacement sibling molcheck_mandate, making it trivially distinguishable from that sibling.

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

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

It states an unambiguous when-not rule: 'Deprecated alias of molcheck_mandate; use that name.' The alternative tool is named and the condition that selects it is explicit, leaving no inference required.

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

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

With no annotations, the description carries the burden and does disclose two behavioral traits: 'Read-only' and the result ordering rule ('Ranks NO_MANDATE / NEEDS_REVIEW lower'). It omits pagination/limits, but for a deprecated zero-param read tool this is solid 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?

Deprecation warning is correctly front-loaded, followed by resource and behavior in short clauses. Slightly awkward line breaks and an adjective-free noun phrase cost it a point, but there is essentially no waste.

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

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

An output schema exists, so return values need not be explained, and the tool's real function (route to molcheck_registry) is fully conveyed. Nothing critical is missing for a deprecated alias with no parameters.

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

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

Zero parameters (baseline 4) and schema description coverage is 100%, so there is no parameter meaning for the description to add or omit.

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

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

The description identifies the resource as 'Agents with committed mandates and their current verdict' and explicitly frames this tool as a deprecated alias of molcheck_registry, which lets an agent place it relative to siblings. The purpose is understandable, though the noun phrase lacks an explicit verb (list/query).

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

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

It gives direct, explicit routing: 'Deprecated alias of molcheck_registry; use that name.' An agent knows immediately not to call this and which sibling to call instead — the strongest form of 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 and does well: it states 'Read-only' and that results are 'Recomputable from public chain data + the public mandate', disclosing determinism, idempotence and that no private/auth-gated state is involved. It omits any note on latency, caching, or error behavior for an unregistered agent, which keeps it short of a 5.

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

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

The deprecation warning is front-loaded, and the body is two short sentences plus a compact arg line with no filler. The pseudo-Google-style 'Args:' block is slightly heavier than needed for a single parameter but 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?

An output schema exists, so return values need not be described, and the description covers deprecation, read-only semantics, data provenance and argument formats. For a one-parameter read tool this is nearly sufficient; only edge cases (unknown agent, no mandate committed) are unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by enumerating the accepted identifier forms: 'agent address, did:moltrust / did:web, or ERC-8004 reference (public)'. That is real semantic value beyond the bare string type, though it gives no 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?

Names the specific resource and output shape ('Verdict + per-check breakdown for an agent against its committed mandate') and immediately disambiguates from the sibling molcheck_verdict by declaring itself a deprecated alias. An agent can identify both what it returns and which tool it should actually prefer without opening any schema.

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

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

Explicitly routes the agent away from this tool ('Deprecated alias of molcheck_verdict; use that name'), which is actionable when-to-use guidance. It does not, however, explain when a verdict is the right check versus molcheck_evidence or molcheck_verify, so routing within the broader family 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 provided, so the description carries the full burden, and it does disclose the key safety profile: 'Offline and read-only: no DID/mandate/context is fetched here.' This is meaningful beyond the schema. It stops short of describing failure behavior (e.g., signature-mismatch outcome), which keeps it from a 5.

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

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

Front-loads the most decision-relevant fact (deprecation) ahead of the functional detail, and the Args block is tidy. Slightly longer than strictly necessary due to the enumerated arg list, but every line 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?

An output schema exists, so return values need not be explained, and the description covers the offline/read-only behavior plus all four undocumented params. Complete enough for an agent to call it correctly, though no guidance on the signature result semantics is given.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all four parameters ('public agent identifier', 'the public AAE Verifiable Credential', 'public, already-decoded on-chain actions', 'optional prior MolCheck signature'). It conveys the semantic role of each param but no format or syntax detail.

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

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

States a specific verb+resource ('Recompute a verdict from public inputs and check its signature') and immediately differentiates itself from siblings by naming the canonical tool molcheck_verify. An agent can tell exactly what this does and that it is a deprecated alias without opening any schema.

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

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

Explicitly routes the agent away from this tool ('Deprecated alias of molcheck_verify; use that name'), which supplies the key when-not-to-use / alternative guidance. It does not fully spell out when the canonical verify is appropriate versus the many other *_verify siblings, so it falls 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?

Annotations already declare non-readOnly, idempotent, and destructive hints; the description adds real behavioral context in the 1 USDC = 100 credit conversion and on-chain verification. However, it never addresses the destructiveHint (what state is consumed by a claim), what happens on a duplicate or invalid tx_hash, or any rate/per-claim limit — gaps an agent needs for a mutating call.

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

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

The purpose and the deposit-then-claim workflow are front-loaded in two tight sentences. The Args block duplicates the schema's parameter descriptions and could be dropped, which is the only wasted space.

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

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

For a two-parameter mutation with an output schema available, the description supplies the essential precondition, the conversion rate, and the verification basis. Missing only the address to send funds to (a sibling tool's job) and error/duplicate handling.

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

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

Schema description coverage is 100%, and the description's Args block restates the exact same content (0x hash, DID to credit) without adding format rules, validation constraints, or example values beyond the schema. Baseline 3 is appropriate when the schema already carries the semantics.

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

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

States a specific verb and resource ('Claim MolTrust credits from a USDC deposit on Base') and adds the mechanism (submit on-chain tx hash to receive credits), which clearly separates it from read-only siblings like moltrust_credits or moltrust_deposit_history. It doesn't name a sibling explicitly, so it stops short of a 5.

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

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

Gives an explicit precondition: USDC must first be sent to the MolTrust wallet on Base, then the tx hash is submitted. That is clear usage context, but there is no exclusion or pointer to moltrust_deposit_info (to get the wallet address) or moltrust_deposit_history (to check prior claims).

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 declare destructiveHint=true and idempotentHint=false, but the description never explains the destructive aspect: what issuing persists, whether a credential can be revoked or overwritten, or whether verification has side effects. With a destructive mutation in the mix, the silence is a real gap; the description neither contradicts nor supplements the 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 opening sentence is well-formed and front-loaded, but the Args block duplicates parameter descriptions already present in the schema, adding length without value. A tighter description would spend those tokens on sibling routing and destructive-behavior disclosure instead.

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?

An output schema exists, so return values need not be explained, but the description omits the behavioral facts an agent needs for a tool flagged destructive and non-idempotent: auth requirements, side effects of 'issue', and how it relates to the dedicated issue/verify siblings. The conditional parameter notes are the only substantive 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?

Schema coverage is 100% and the description's Args block essentially restates the schema descriptions verbatim (and drops the DID example the schema provides), adding no new meaning. Baseline 3 is appropriate since the schema already carries the parameter semantics.

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

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

The first sentence states a specific verb pair and resource: issuing or verifying a W3C Verifiable Credential. It is clear what the tool does, but it does not distinguish itself from the many credential siblings (moltguard_credential_issue, moltguard_credential_verify, moltrust_verify), so an agent cannot tell from the description alone why this combined tool exists alongside them.

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

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

There is no guidance on when to use this tool versus moltguard_credential_issue or moltguard_credential_verify. The 'required for issue/verify' notes are conditional-parameter facts rather than usage routing, and nothing says when the combined action interface is preferable to the dedicated 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows some operations here can mutate state. The description adds useful validation context (amount must be >= 1) and action-specific required fields, but it does not disclose whether transfers are irreversible, whether authentication/authorization is required, or what side effects occur beyond the annotation flags.

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 main purpose and then organized into a compact Args block, making it easy to scan. The parameter listing duplicates the schema, but given the multi-action nature it remains reasonably efficient and not bloated.

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 7-parameter multi-action tool with an output schema and full input schema descriptions, the description covers the action menu and per-action required parameters adequately. It omits some behavioral details such as transfer irreversibility and auth requirements, but annotations cover the destructive nature and the output schema handles return values.

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

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

Schema description coverage is 100%, so the schema already documents each parameter in detail. The description largely repeats the schema descriptions, including action-conditional requirements, and adds little semantic meaning beyond what is already structured. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The first sentence names the resource (MolTrust credits) and gives a concrete action menu: check balance, view pricing, transfer credits, view transaction history. It is clear what the tool does, though the multi-action nature means it is less sharply scoped than a single-purpose tool, and it does not explicitly differentiate itself from sibling moltrust_* 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 Args section clearly maps each action to its required parameters, giving an agent the context needed to choose and invoke the right variant. It does not explicitly state when to use this tool versus siblings, but for a multi-action tool the action-level guidance is clear enough to be above baseline.

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?

readOnlyHint=true already establishes this is a safe read, so the description's burden is lighter, and it does add that the scope is a single agent and a single asset (USDC). Beyond that it says nothing about whether history is complete or capped, whether time ranges apply, or whether results are paginated — for a tool literally named 'history' those gaps matter.

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

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

The opening sentence is front-loaded and efficient, but the 'Args: did: The agent's DID' block is pure duplication of the schema and earns no space. Short overall, but not every line pays for itself.

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?

An output schema exists, so return values need not be explained, and the single parameter is well covered by the schema. What is left unexplained is scope-relevant for a history endpoint: result window, pagination, and ordering — enough of a gap to keep this at minimum-viable rather than 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?

Only one parameter and schema coverage is 100%, with the schema even supplying a concrete example DID format. The description's 'The agent's DID' adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: retrieve USDC deposit history, scoped to an agent. That is unambiguous, but it never distinguishes itself from near-name siblings such as moltrust_deposit_info, moltrust_claim_deposit, or moltrust_credits, so the agent must guess among them.

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

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

There is no when-to-use guidance, no exclusions, and no mention of the deposit-related siblings that could plausibly be confused with this one. The agent learns what the tool returns but not when to prefer 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?

readOnlyHint=true is consistent with an info-only tool, and the description reinforces this by describing the data returned (wallet address, token contract, conversion rate, steps). It does not mention whether an account/credential is needed to call it, or any rate limits, but with the annotation already covering the safety profile and an output schema covering returns, the remaining gap is modest.

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

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

Two short sentences, purpose front-loaded, followed by an enumerated list of what comes back. Nothing redundant and no filler.

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

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

For a zero-parameter read-only tool with a full output schema, the description covers purpose, network (Base L2), asset, and conversion rate — enough to call it correctly. The only omission is what to do after depositing (e.g., moltrust_claim_deposit), which is a usage-guidance gap rather than a completeness failure.

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

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

The tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate beyond confirming the tool needs no 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?

States a specific verb+resource ('Get USDC deposit instructions') plus the business goal ('to buy MolTrust credits'), so the agent knows exactly what this returns. It does not explicitly contrast with near-name siblings such as moltrust_claim_deposit or moltrust_rate, so differentiation is left to inference.

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' implies the context of use, but there is no explicit when-to-use/when-not guidance and no mention of the natural follow-up tool (moltrust_claim_deposit) after sending funds. Usage is implied rather than stated.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context — it contributes the chain (Base) and the fact that data comes from an on-chain registry. It says nothing about latency, caching, what happens when a DID or agentId is not found, or whether 'well-known' touches a network 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?

Front-loaded one-line summary, then a compact Args block; every line is short and scannable. The Args section largely duplicates the schema, which is the only noticeable 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?

An output schema exists so return values need no explanation, and all three actions are enumerated. Still missing enough to call it complete: no routing versus the several registry siblings, no note on which action is the default entry point, and no error/absence behavior for a read that may return nothing.

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

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

Schema description coverage is 100% and the description's Args block restates the schema text almost verbatim, including the identical example values. The one small addition is the action-to-parameter dependency, which the schema conveys less explicitly; otherwise this is baseline for fully documented parameters.

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

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

States a specific verb and resource — query the ERC-8004 on-chain agent registry on Base — and enumerates the three operations (card, resolve, well-known). The multi-mode packaging blurs the single purpose somewhat, and no sibling is named even though molcheck_registry and moltproof_registry appear adjacent.

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 Args section implies which mode to use by pairing action values with their required parameters (did for card, agent_id for resolve), which is better than nothing. But there is no explicit guidance on when to choose this registry tool over molcheck_registry or moltproof_registry, nor any stated preconditions or failure paths.

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 already flag destructiveHint=true and idempotentHint=false, which raises an obvious question the description ignores: does a new rating overwrite a prior one, and is that history lost? Nothing is said about overwrite behavior, auth/ownership checks on from_did, rate limits, or whether self-rating is permitted. It does not contradict the annotations, but it adds almost nothing beyond them.

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

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

The opening line and the 'Submit a trust rating...' sentence say the same thing, and the Args section duplicates a fully documented schema. The core content is short, but roughly half of it is redundant rather than front-loaded 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?

An output schema exists and all three params are schema-documented, so the basics are covered. What is missing for a destructive, non-idempotent write is the effect of re-rating and any identity/permission requirement on from_did — information an agent needs before calling.

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

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

Schema coverage is 100% and the Args block simply repeats the schema descriptions verbatim, so no additional meaning is conveyed. Baseline 3 applies when the schema already documents every 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 states a specific verb and resource ('rate another AI agent', 'submit a trust rating from one agent to another') with the 1-5 scale spelled out. It is clear on its own, but it never distinguishes itself from nearby endorsement/reputation siblings such as mt_endorse_agent or moltrust_reputation, so an agent must infer the difference.

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

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

There is no statement of when to use this versus alternatives, no prerequisites (must either agent be registered? does the target need to exist?), and no exclusions. The second line merely restates the first, so the agent gets no routing guidance at all.

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

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

The description adds real context beyond annotations: it discloses that a DID and verifiable credential are created and that the agent is anchored on the Base blockchain, which signals persistence. However, with destructiveHint=true and idempotentHint=false already declared, it never warns about irreversibility, cost, or what happens on repeat/duplicate registration calls.

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

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

The first sentence and the three-line summary of created artifacts are well front-loaded and earn their place. The trailing 'Args:' section duplicates the input schema word-for-word and is pure 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?

An output schema exists, so return values need not be explained, and the description adequately covers what is created. But for a non-idempotent, destructive, blockchain-writing operation in a crowded sibling namespace, the absence of cost/permission/irreversibility guidance leaves meaningful gaps.

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

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

Schema description coverage is 100%, so the 'Args' block is a verbatim restatement of the schema's own parameter descriptions and adds no new meaning (no format examples or normalization notes). Baseline 3 applies when the schema carries the semantic load.

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 opening sentence states a specific verb and resource ('Register a new AI agent on MolTrust') and the body enumerates the concrete artifacts produced (DID, W3C Verifiable Credential, Base blockchain anchor). It is distinguishable from moltrust_verify/moltrust_credential by naming, though it does not explicitly contrast with sibling registrar tools like mt_register_seed or mt_salesguard_register.

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

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

There is no statement of when to use this tool versus the many sibling registration/verification tools, and no prerequisites (funding, credits, wallet, prior deposit) are mentioned. The agent must infer usage context entirely from the name.

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

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

readOnlyHint=true already establishes this is a safe read, so the burden is lower. The description adds the return shape (1-5 aggregate plus a rating count), which is useful behavioral context, but says nothing about unrated agents, missing DIDs, or error behavior.

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

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

The purpose and return statement are front-loaded and efficient. The subsequent Args section duplicates the schema text with no added value, which is minor waste but not harmful.

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, the description needn't expand further on return values, and the single required parameter is fully documented. What's missing is sibling disambiguation and any note on behavior for unrated or unknown DIDs, which matters given how many adjacent scoring tools 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 coverage is 100% for the single `did` parameter, so the baseline is 3. The description's Args block reproduces the schema's example string verbatim rather than adding format rules, validation constraints, or DID resolution notes.

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

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

States a specific verb and resource — retrieve an AI agent's reputation score — which is clear on its own. However, it does not distinguish itself from plausible siblings such as mt_get_trust_score, moltguard_score, or moltrust_stats, leaving overlap ambiguous.

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

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

No guidance on when to call this versus the many sibling score/trust tools. There are no exclusions, prerequisites, or conditions given, so the agent must infer selection from names alone.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful detail by naming the metrics returned, but 'other network health metrics' is vague and the output schema already defines the actual return shape.

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

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

Two short sentences with the core purpose front-loaded and no filler. The only mild weakness is the trailing catch-all phrase 'and other network health metrics'.

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

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

For a zero-parameter, read-only stats tool with an output schema, the description supplies enough context to call it correctly. Return-value details are appropriately left to the output schema.

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

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

The tool takes no parameters, so there is nothing to clarify and the baseline of 4 applies. The schema coverage is 100%, and no additional parameter semantics are needed.

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

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

The description names a specific verb and resource ('Get MolTrust network statistics') and enumerates the metrics returned (registered agents, credentials issued, ratings given). It is unambiguous on its own, though it does not explicitly differentiate itself from similarly named siblings such as mt_get_swarm_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?

There is no guidance on when to call this tool versus alternatives, no preconditions, and no exclusions. The name implies it is a read-only dashboard call, but the description leaves usage context 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds value by disclosing the payload shape (registration status plus reputation, credentials, blockchain anchor), but leaves open what happens for an unregistered DID — error versus a negative status — and says nothing about cost, rate limits, or whether calls are metered against credits.

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 front-loaded sentences state the action and the result before any detail. The trailing Args block is largely redundant with a 100%-covered schema, a small amount of waste but not enough to undermine the structure.

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

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

With an output schema present, the return-value description need not be exhaustive, and one required parameter with full schema coverage keeps the surface simple. The remaining gap is behavioral: no statement of the unregistered/nonexistent-DID outcome, which matters for an agent branching on the result.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema; the description's Args block restates that text verbatim rather than adding format constraints, alternate DID namespaces, or expected failure modes. Baseline 3 applies when the schema already carries the parameter semantics.

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

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

Specific verb (verify) plus resource (an AI agent identified by DID), with a concrete statement of what is checked and returned. It does not distinguish itself from the many sibling verify tools (molcheck_verify, moltproof_verify, mt_*_verify), so an agent cannot tell from the text alone which verification surface this belongs to.

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

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

Usage is implied by the verb — an agent would call this to check whether a DID is registered — but there is no explicit when-to-use, no prerequisites (e.g. does the agent need to be registered first?), and no routing away from the similarly named verification 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?

The readOnlyHint annotation already establishes this is a safe read, so the bar is lower. The description adds useful context about the response shape ('yes/no with tier and expiry'), but says nothing about what happens on an unknown DID, whether expiry is evaluated against now, or any auth/rate constraints.

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

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

The purpose is front-loaded in the first sentence and the return expectation follows immediately. The trailing Args block duplicates the schema and could be dropped, but overall the description is short and earns most of its space.

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?

An output schema exists, so the description needn't detail return structure, and the single required parameter is fully documented. For a one-parameter read tool this is close to complete; only the sibling-routing guidance against mt_get_badge is missing.

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

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

Schema description coverage is 100% and the single 'did' parameter already carries a concrete format example (did:moltrust:a1b2c3d4e5f60718). The 'Args: did: The DID of the agent to check' block merely restates the schema, adding no new semantics.

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

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

The description states a specific verb and resource ('is this agent badge-verified by MolTrust?') and names what is returned ('simple yes/no with tier and expiry info'). It is clear on its own, but it never distinguishes itself from the obvious sibling mt_get_badge, which presumably returns a fuller badge record.

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?

'Quick check' implies a lightweight lookup, but the description never says when to prefer this over mt_get_badge or mt_get_trust_score. Usage is only implied by the word 'quick', leaving the agent to guess at the alternative.

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

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

Annotations only tell the agent this is a non-read-only, non-destructive, non-idempotent call; the description adds that the result is anchored on Base L2 with evidence_hash and base_tx_hash, and that the artifact expires in 72 hours. That on-chain anchoring and TTL context is real value beyond the annotations. It does not mention cost/gas implications or what happens if a duplicate proof is requested (relevant given idempotentHint=false).

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

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

The first three lines are front-loaded and dense: purpose, outputs, prerequisite, expiry. The trailing Args block duplicates a schema that is already 100% documented, which is wasted surface area, but the rest of the description is tight.

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

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

For a mutation tool that issues a short-lived on-chain-anchored proof, the description covers the trigger condition, the dependency on mt_endorse_agent, the return hashes, and expiry, and an output schema exists so result shape need not be spelled out. Minor gaps are the absence of cost, error/retry behavior, and whether the proof is bound to one specific agent pair.

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

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

Schema coverage is 100% and the Args block in the description repeats the schema text almost verbatim, so no new meaning is added for any of the five parameters. The one useful implication — that outcome and interaction_type are constrained to a small value set — is conveyed only as examples, and no enum is enforced in the schema.

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

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

States a specific verb and resource ("Create an interaction proof") and immediately ties it to a downstream consumer, SkillEndorsementCredential, which separates it from the many mt_* verify/issue siblings. It does not differentiate itself from adjacent proof/evidence tools (moltproof_evidence, molcheck_evidence), but the operation itself 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?

"Required before calling mt_endorse_agent" gives an explicit ordering constraint and names the alternative that depends on it. "Valid for 72 hours" tells the agent the proof is short-lived and shouldn't be cached indefinitely. It stops short of saying when not to use it or how to refresh an expired proof.

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 already cover readOnly=false, idempotent=true, destructive=false, and the description adds valuable behavioral context: the evidence-hash freshness constraint, self-endorsement rejection, and the downstream effect on the endorsed agent's Trust Score. It doesn't explain idempotent behavior directly, so 4.

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

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

The core purpose and prerequisites are front-loaded in three tight sentences. The Args block duplicates schema text and adds length without much new information, slightly diluting 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?

A mutation/issuance tool with an output schema present, so return values needn't be described. Prerequisites and consequences are covered; the main small gap is not distinguishing from sibling issuance tools, but the definition is complete enough to call correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's Args section largely restates the schema field descriptions, adding only the renamed 'endorser_api_key' phrasing and cross-referencing mt_create_interaction_proof for two fields, but not meaningfully extending semantics.

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

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

States a specific verb ('Issue') and resource ('W3C SkillEndorsementCredential for another agent'), which clearly distinguishes it from verify/score siblings. It does not explicitly differentiate from other issuance tools like mt_skill_issue_vc, so a 4 rather than 5.

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

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

Provides concrete prerequisites: a valid evidence_hash from mt_create_interaction_proof no older than 72h, and that self-endorsement is rejected. It lacks explicit guidance on when to choose this over sibling issuance tools, keeping it below 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?

Annotations already declare readOnly=false, idempotent=true, destructive=true. The description adds useful context beyond them: the output is a W3C VC whose hash is anchored on Base L2, and the lineup is 'locked', implying irreversibility. However, it never explains why the operation is destructive, what cannot be undone after commit, whether the agent DID must be registered first, or what happens if a contest is already started beyond 'must be in the future'.

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

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

The first paragraph is well front-loaded and earns its place, but the Args block is a verbatim restatement of the input schema's property descriptions and provides no new information to an agent that already receives the schema. Roughly half the text is redundant for a schema-aware caller.

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 10 parameters and an output schema, and the description covers purpose, mechanism, and inputs, so the core is present. It omits preconditions that matter for a destructive, money-attached operation (agent identity/registration requirements, whether failure cases like a past contest start return an error, gas/anchoring latency), leaving gaps for an agent deciding whether to invoke it.

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

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

Schema coverage is 100%, so the baseline is 3; the description restates the same argument documentation with examples (DID format, contest_id, ISO 8601 format, lineup_json example) and clarifies the acceptance rule 'must be in the future'. It adds examples beyond the schema but largely duplicates it.

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?

First line gives a specific verb (commit) plus resource (fantasy lineup) and states the mechanism (SHA-256 hash anchored on Base L2). It follows with the artifact produced (a FantasyLineupCredential W3C VC) proving the lineup was locked before contest start. It does not explicitly distinguish itself from mt_fantasy_verify or mt_fantasy_history, but the write-vs-read distinction is inferable from 'commit' and 'locked'.

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

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

There is no explicit when-to-use / when-not-to-use guidance and no mention of the sibling tools (mt_fantasy_verify, mt_fantasy_history, mt_prediction_*) that an agent might pick instead. The only usage constraint given is that contest_start_iso must be in the future, which is a precondition rather than 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?

The description frames this as a retrieval ('Get ... history and stats') while annotations declare readOnlyHint=false and destructiveHint=true. That is a direct contradiction of the safety profile an agent relies on; no side effects, permissions, or destructive behavior are explained.

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

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

Front-loaded with purpose and return contents in two short sentences. The trailing Args block restates the schema but is small and not disruptive.

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?

Output schema exists so return values need no explanation, but for a tool annotated destructive, the description gives zero context about what could be destroyed or what authorization is needed. The contradiction leaves the agent materially misinformed.

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

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

Schema description coverage is 100% and the single 'did' parameter is fully documented with an example. The description merely repeats the same DID example from the schema, adding no extra semantics.

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

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

States a specific verb and resource: fetching fantasy lineup history and stats for an agent DID, including the metrics returned (ITM rate, ROI, projection accuracy). It is clearly distinguishable from mutation siblings like mt_fantasy_commit and mt_fantasy_verify, though it never names them.

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

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

No guidance on when to use this versus mt_fantasy_verify, mt_fantasy_commit, or other stats tools, and no prerequisites or exclusions. Usage is only implied by the word 'history'.

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?

readOnlyHint=true is consistent with a verification tool, and the description adds value beyond the annotation by disclosing that no auth is needed and what the response contains (lineup, timing proof, on-chain status, credential). It does not discuss failure modes, e.g. what happens for an unknown or unconfirmed hash.

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

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

Front-loaded with purpose, then auth, then return payload; the only waste is the Args block, which duplicates the input schema for a single parameter. Overall tight 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?

With an output schema, readOnlyHint, and full schema coverage, the remaining burden is small: auth requirement, payload summary, and param format are all covered. Only error/edge-case behavior is unaddressed.

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

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

Schema coverage is 100%, so the baseline is 3. The description's Args line repeats the schema text verbatim ('The 64-char SHA-256 commitment hash') and adds no format, encoding, or sourcing guidance beyond what the schema already states.

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

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

States a specific verb and resource ('Verify a fantasy lineup commitment'), which is clearly separable from the write-side sibling mt_fantasy_commit and from mt_fantasy_history. It never names those siblings explicitly, so the differentiation is inferred from the verb rather than stated.

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

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

'Public endpoint, no auth required' gives useful call context, but there is no explicit statement of when to use this versus mt_fantasy_commit or mt_fantasy_history. The usage (verify a commitment that was previously committed) is only implied.

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

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

The readOnlyHint annotation already establishes the safe read-only profile. The description adds the returned fields, but those are also covered by the output schema, and it does not add auth requirements, rate limits, or side-effect context beyond what the annotations provide.

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 core action and return values stated first. The Args section is redundant with the schema, but the overall text 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?

This is a simple read-only lookup with full schema coverage, an output schema, and readOnlyHint annotations. The description is complete enough to call the tool correctly, though it could better route the agent away from sibling tools.

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

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

Schema description coverage is 100%, and the schema already documents the single did parameter with an example. The description only restates that it is the DID of the agent to check, adding no meaningful semantics beyond the schema.

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

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

The description states a specific verb and resource: 'Get the Verified by MolTrust badge status for an agent.' It clearly explains what is returned, but does not differentiate itself from closely related siblings such as mt_check_badge or mt_get_trust_score.

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

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

The description implies that this tool checks an agent's badge, but it gives no explicit when-to-use guidance, no exclusions, and no comparison with alternatives like mt_check_badge or mt_get_trust_score.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuinely non-obvious context beyond that: the traversal is fixed at 2 hops and the response splits into scored nodes and endorsement edges, which affects how results should be interpreted. It doesn't mention cost, rate limits, or behavior when the agent has no endorsements, keeping it out of the top band.

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

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

The core sentence is front-loaded and the hop limit is stated immediately, which is the right priority. The trailing Args section duplicates the schema verbatim and is the one piece that doesn't earn 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?

An output schema exists and annotations cover read-only semantics, so the description only needs to frame the operation. It does that by disclosing the 2-hop depth and the node/edge shape, leaving little an agent needs to guess before calling it.

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

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

There is a single parameter with 100% schema description coverage, including a concrete example DID, so the schema already carries parameter meaning. The description's Args block only restates the schema's own text, adding nothing new.

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

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

States a specific verb and resource ("Get the trust propagation graph for an agent") plus its scope limit (2 hops), and describes what the result contains (nodes with scores, endorsement edges). This is enough to tell it apart from single-value siblings like mt_get_trust_score or aggregate siblings like mt_get_swarm_stats, though no sibling is named explicitly.

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

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

Usage is only implied by the description of the output: an agent can infer it should call this when it needs endorsement relationships rather than a score. There is no explicit when-to-use statement and no mention of alternatives such as mt_get_trust_score for a plain score lookup.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation, and the tool has no parameters. The description adds the scope ('global') and lists the metrics, but it does not disclose freshness, caching, computation window, or any rate/authorization context beyond what annotations and the output schema already provide.

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, front-loads the purpose, and uses the second sentence only to enumerate the returned statistics. There is no filler or repetition.

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

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

For a parameterless, read-only statistics tool with an output schema, the description is nearly complete: it states the purpose and names the metrics returned. The remaining gap is the lack of routing guidance among the many sibling stats and graph tools.

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

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

The tool takes zero parameters, so there is no parameter behavior for the description to document. The baseline for a parameterless tool is 4, and no contradiction or missing parameter information is present.

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 global Swarm Intelligence statistics') and enumerates the metrics returned, so the agent knows exactly what the tool provides. It does not distinguish itself from sibling tools such as mt_get_swarm_graph or mt_get_trust_score, 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?

There is no explicit guidance on when to use this tool versus alternatives. The word 'global' implies aggregate statistics rather than per-agent or graph views, but no sibling tool is named and no inclusion or exclusion conditions are given.

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

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

The readOnlyHint annotation already establishes this is a safe read, so the description only needs to add context. It does add useful content by naming what comes back (track metadata, provenance hash, EU AI Act compliance status, on-chain anchor info), but says nothing about error behavior when a credential_id does not exist or whether results are cached/live.

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

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

The first sentence is front-loaded and states the purpose immediately, and the return-value list adds value. The trailing Args block duplicates the schema verbatim and is the one mildly wasteful element.

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 required parameter, full schema coverage, an output schema, and a readOnlyHint, the definition covers what an agent needs to invoke it. The only real gap is sibling differentiation, which the description leaves out.

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

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

Schema description coverage is 100% and the single parameter is documented as 'UUID of the music credential' in the schema. The description's Args block restates that identically without adding format constraints or fallback behavior, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Get full provenance details for a music credential') and enumerates the returned content, so the purpose is unambiguous. However, it never distinguishes itself from close siblings such as mt_verify_music_credential or mt_issue_music_credential, which an agent must otherwise infer.

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

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

There is no statement of when to use this tool versus mt_verify_music_credential or mt_get_badge, nor any prerequisites or exclusions. The retrieval intent is only implied by 'Get full provenance details'.

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 only declare readOnlyHint=true, so the description carries the behavioral burden and does so well: it discloses the score's inputs (endorsements, propagated trust, credential bonus, interaction proof) and, critically, the withheld/null outcome below 3 independent non-seed endorsers, plus the seed-agent exception. It stops short of stating freshness, caching, or whether repeated calls are stable, which is why it is not a 5.

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

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

The core paragraph is front-loaded and each sentence earns its place, describing composition then edge-case behavior. The trailing 'Args: did: ...' block is redundant with the input schema and could be dropped, which keeps it from a 5.

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

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

With an output schema present, the description needn't explain return shapes, and it covers the one genuinely surprising outcome (withheld score) plus the seed-agent carve-out. For a single-parameter read tool this is nearly complete; only freshness/versioning of the score is unaddressed.

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

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

Schema description coverage is 100% and the single parameter is fully documented. The description's Args block restates the schema text verbatim (including the example DID), adding no semantics beyond what the structured field already provides, so baseline 3 applies.

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

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

States a specific verb+resource: it returns the Swarm Intelligence Trust Score for a given agent, and the 'Phase 2' label plus the named score inputs give it a concrete identity. It does not explicitly distinguish itself from nearby siblings like moltrust_reputation or moltguard_score, so an agent must infer which score to call.

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 rather than stated: score an agent's trust when you have a DID. The threshold behavior ('fewer than 3 independent endorsers' → withheld) quietly signals when the tool is useful versus premature, but there is no explicit when-to-use/when-not or named alternative among the many sibling scoring 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?

Annotations already flag a mutating, non-idempotent, destructive operation; the description adds real value beyond them by disclosing cost ($5/$20), a 1-year validity window, and automatic revocation on trust-score decline. What's missing is what happens on re-issue (does it charge again / replace the badge), which matters given idempotentHint=false.

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?

Tier economics and validity are front-loaded and compact; every sentence conveys useful information. The trailing Args block duplicates the input schema and could be dropped, but it costs little.

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, the description needn't explain return values, and it covers the decision-relevant facts: price, thresholds, duration, and revocation behavior. Missing only edge-case behavior around re-issuance and prerequisites on the DID itself.

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

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

Schema description coverage is 100% and the Args block merely repeats the schema's own wording for 'did' and 'tier' verbatim, adding no syntax, format, or enum constraints beyond what the schema states. Baseline 3 applies since the schema carries the parameter burden.

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

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

States a specific verb and resource ('Issue a Verified by MolTrust badge for an agent'), which cleanly separates it from the sibling read tools mt_check_badge and mt_get_badge. The tier names also identify the concrete artifact being created.

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

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

Gives eligibility thresholds (score 40+ for 'verified', 60+ for 'trusted') and pricing, which tells the agent when issuance is possible. It stops short of naming alternatives (e.g. use mt_check_badge before issuing) or stating exclusions such as whether a badge already exists.

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 already declare readOnlyHint=false and destructiveHint=true, and the description usefully adds that the credential is anchored on Base L2 — an on-chain, likely irreversible write. However it never explains cost/gas, whether re-issuing the same track creates a duplicate credential (annotation says non-idempotent), or why issuance is flagged destructive. Those are the behaviors an agent most needs before invoking a write 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?

Purpose and compliance framing are front-loaded in the first two sentences, then parameters follow in a scannable list. The Args section is redundant with a fully documented schema, which is the only real waste, but the description is appropriately sized for an 8-parameter issuing 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?

With an output schema present, the description needn't explain return values, and it covers the substantive gaps: what the credential attests, the anchoring chain, and the regulatory basis. Missing pieces are operational (cost, duplicate handling on re-issue), which keeps it just short of complete.

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

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

Schema description coverage is 100%, so every parameter is already documented, and the Args block largely restates the schema text verbatim. The one meaningful addition is the DID format example, but the enum-like values for human_oversight are already in the schema. Baseline 3 applies.

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

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

States a specific verb and resource ("Issue a VerifiedMusicCredential for an AI-generated music track") and immediately clarifies what the credential proves: provenance, originating tool, human involvement, and rights. This clearly distinguishes it from mt_verify_music_credential and mt_get_track_provenance, which read rather than 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 establishes context (provenance attestation, EU AI Act Article 50(2), Base L2 anchoring) that implies when to use it, but never names an alternative or a when-not-to-use condition. An agent must infer from the sibling names that verification/provenance lookup happens elsewhere.

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?

readOnlyHint=true already tells the agent this is a safe read. The description adds genuine value by disclosing the score composition (win rate, ROI, volume, sample size, recency) and that results are ranked, but it says nothing about pagination, snapshot timing, or how ties or minimum-activity thresholds are handled.

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

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

The purpose and ranking explanation are front-loaded and tight. The trailing "Args:" block duplicates the schema field description, which is mild waste but not damaging.

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 annotations covering the safety profile, the description needn't explain return values. It covers purpose, ranking basis, and the limit bound, leaving only minor gaps around result freshness and pagination.

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

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

Schema coverage is 100% and the single limit parameter is fully documented in the schema, including the default 20 and max 100. The description merely echoes that text verbatim, adding no new semantics, so the baseline 3 applies.

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

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

States a specific verb and resource ("Get the prediction market leaderboard — top wallets by prediction score") and clarifies the ranking basis. It is unambiguous on its own, though it does not explicitly distinguish itself from nearby siblings like mt_prediction_wallet or mt_prediction_link.

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

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

There is no statement of when to use this versus alternatives, no preconditions, and no exclusions. The reader must infer that mt_prediction_wallet serves per-wallet lookups rather than leaderboard browsing.

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?

Beyond annotations, the description explains the operational flow: fetching trade history from Polymarket, calculating a 0-100 prediction score, storing the wallet profile, and optionally linking a MolTrust DID. It does not mention permission requirements or rate limits, but it provides substantive context about what happens during the call.

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 main action and flow, then lists arguments. The Args section duplicates the schema almost verbatim, which is slightly redundant, but the overall size and structure remain 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 tool is a mutating operation with an output schema and annotations, and the description adequately explains the fetch-calculate-store-link flow. It does not cover edge cases such as re-linking an existing wallet, but it is complete enough for 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?

Schema description coverage is 100%, so the schema already documents all three parameters. The Args section repeats the same information without adding format, constraints, or meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the specific verb and resource: linking a prediction market wallet and syncing its track record, with additional detail about fetching trade history, calculating a score, and storing a wallet profile. It does not explicitly distinguish this from the sibling mt_prediction_wallet, so sibling differentiation is left implicit.

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 describes what the tool does but gives no explicit guidance on when to use it versus alternatives such as mt_prediction_wallet or mt_prediction_leaderboard. Usage is only implied by the action of linking and syncing.

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?

readOnlyHint=true already establishes this is a safe read, so the description only needs to add context. It does add the content of the result (score, win/loss, volume, ROI, breakdown, recent events), but repeats what the output schema likely already declares and says nothing about freshness, caching, or behavior for unknown wallets.

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