MarketNow

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered. The description adds the useful fact that this is a scoring lookup returning a score plus reasons, but says nothing about latency, rate limits, or how to interpret the score. Adequate but thin beyond 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?

Two short sentences, zero filler, with the core purpose front-loaded before the return-value note. Nothing could be removed without losing information.

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

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

For a one-parameter read-only lookup with complete annotations and no output schema, the definition covers purpose and the shape of the result. It is nearly complete; only score interpretation and failure behavior are unstated.

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

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

Schema coverage is 100% and the schema already documents the single 'domain' parameter with an example. The description adds no format, normalization, or edge-case detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb ('Check') and resource ('domain') with a plain-language gloss ('scam checker') and the return payload (risk score and reasons). It does not differentiate from any sibling, but the siblings operate on unrelated domains (revocation, fingerprint, pipeline), so confusion risk is low.

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

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

The description gives no when-to-use context, no prerequisites, and no indication of when a different tool (e.g. marketnow_verify_trust) would be the better choice. The parenthetical '(scam checker)' implies intent but stops short of 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?

Beyond the annotations (which already cover readOnly/idempotent/non-destructive), it discloses the full result vocabulary, the PERMIT/DENY recommendation, the fail-closed UNKNOWN+DENY rule, and the Ed25519/RFC 8785 JCS verifiability of the CRL layer. This is rich behavioral context an agent could not infer from structured fields.

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, followed by return values, fail-closed semantics, and verification detail — each sentence adds distinct information 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?

No output schema exists, and the description compensates by enumerating return values and the DENY recommendation, plus failure behavior. An agent has everything needed to call and interpret 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 kid and card_id are already documented with examples. The description adds only the either/or framing of the two subject identifiers and says nothing about nonce mechanics beyond what the schema states. 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 (check), the exact resource (revocation status), and the two subject types it accepts (card_id or kid) against a named registry. It clearly distinguishes itself from verify_trust and check_domain by naming the revocation-registry scope.

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

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

The description conveys the scenario (verify a card or CA key hasn't been revoked) and the fail-closed posture, but never explicitly states when to prefer it over siblings like marketnow_verify_trust. Usage 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?

Annotations already establish the safe read-only, idempotent, non-destructive profile, so the description only needs to add context beyond that — which it does by disclosing the deterministic algorithm (JCS + sha256), the two levels of output (per-tool plus whole-manifest), and the drift categories returned. It stops short of describing error handling or what a changed-vs-added entry looks like structurally.

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

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

Three sentences, all load-bearing: the first defines the operation and standard, the second defines the output surface, the third defines the optional drift behavior. Front-loaded with the core action before the conditional 'pinned' path.

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

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

With no output schema, the description usefully characterizes the return structure (per-tool fingerprint, manifest fingerprint, drift report), which is what an agent needs to interpret results. Nested-object handling is covered by the schema and the description's shape hints. It could say slightly more about the fingerprint value format or failure cases, but nothing essential is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema: it explains that 'pinned' is a previous manifest and that supplying it yields a drift report broken into added/removed/changed. The 'tools' parameter is left to the schema, which already documents its shape.

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 precise verb+resource ('Cryptographically fingerprint MCP tool definitions') and immediately scopes what is fingerprinted (RFC 8785 JCS + sha256 per tool, plus a manifest fingerprint for the whole tools/list surface). It is instantly distinguishable from sibling tools like verify_trust or check_revocation, which operate on different objects.

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 a clear trigger ('verify tool descriptions haven't changed') and spells out the conditional behavior that selects the drift-report path via the 'pinned' argument. It does not name any sibling alternative, but the siblings occupy unrelated domains, so the omission is minor.

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, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds useful content context by disclosing the shape of what is returned: a 12-stage pipeline spanning PARSE to DECISION.

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

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

A single front-loaded sentence naming the resource and its scope, with no filler or redundancy.

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

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

For a zero-parameter read with strong annotations and no output schema, the description is sufficient: it identifies the resource and hints at the returned stage structure. Minor gap is the absence of any guidance on when to consult 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-param tool 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 ('Get') and resource ('credential-verification pipeline') with a quantified scope (12 stages, PARSE→DECISION). It is clearly distinct from sibling check tools, though it does not explicitly say so.

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, when-not-to-use, or alternative guidance is given. The agent must infer that this is a lookup for understanding the verification stages; nothing routes it relative to the other marketnow 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 declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description adds useful content-level context: the exact cardinality (9 formats) and the fields returned (algorithms, status), which annotations cannot convey.

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

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

A single front-loaded sentence naming the action, the count, the enumerated values, and the returned attributes. No filler, nothing redundant.

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 enumeration with no output schema, the description supplies everything needed: the set of formats and the per-format fields (algorithms, status). Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-parameter tool applies. No misleading parameter claims are made.

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 (List) and resource (credential adapter formats), and enumerates the exact 9 formats returned along with their algorithms and status. This clearly distinguishes it from mutation-oriented siblings such as marketnow_translate_credential and marketnow_verify_trust.

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 (discover supported formats before translating or verifying a credential), but the description never states when to call this versus siblings, nor any prerequisite or exclusion. Adequate but leaves routing 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and a closed-world scope, so the safety profile is covered structurally. The description adds only the corpus scope (indexed sources, security-first scoring), with no note on ranking, result limits, or refresh/coverage caveats.

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

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

A single front-loaded sentence that names the action and the resource immediately, with the parenthetical detail earning its place by conveying corpus breadth and trust signal. No filler or redundancy.

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

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

For a simple two-parameter read-only search with no output schema, the description is minimally adequate but silent on what a result contains and how results are ordered, which matters for an agent deciding whether to rely on it. It stops at the purpose statement.

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 both parameters are documented in the schema, so the baseline is 3. The description adds nothing about query syntax, how 'category' values are determined, or the fact that neither parameter is required.

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

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

The description gives a specific verb ('Search') and a clearly bounded resource ('MarketNow registry of indexed MCP servers'), plus useful scale context (68k+, GitHub/npm/PyPI, security-scored). It does not explicitly distinguish itself from siblings, though most siblings (check_domain, fingerprint_tool, translate_credential) are obviously different operations.

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 or when-not-to-use guidance, no mention of alternatives, and no statement of prerequisites or intended context. An agent must infer that this is the discovery entry point of the registry rather than being told.

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?

Far exceeds what the annotations convey: it discloses the Sentinel scan dimensions (injection, secrets, dangerous APIs, typosquat, dedup), live verification of repo_url and install claims, the 422 rejection path, storage in a public auditable queue at certified-L1.5, and that description-only submissions are accepted but never merged. The 'no auth required' and 'do not include secrets' notes add operational constraints annotations don't cover.

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 core action and keeps a logical flow from validation to storage outcome. It is dense and somewhat long, with the pricing point repeated ('Any pricing model is accepted' restates the schema enum), but nearly every sentence carries substantive 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?

Despite no output schema, the description explains the full outcome space: 422 on false claims, queue storage, L1.5 certification, pending L2 review, and the description-only carve-out. An agent has everything needed to call it and understand 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%, so the nested skill package fields and dry_run are already documented in the schema. The description largely restates that pricing models are accepted (already in the schema enum), adding context but little new per-parameter meaning. 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 ('Publish a skill to the MarketNow catalog') and explicitly marks its position in the API surface as 'the write side', which cleanly separates it from read siblings like marketnow_search_skills. An agent can identify what the tool does without opening the 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?

Clear context for when to invoke (publishing a skill package) and it explains dry_run for validate-only use. It doesn't explicitly contrast against siblings such as marketnow_get_pipeline, but the write-side framing plus the validation pipeline description gives strong implied 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and closed-world, so the safety profile is covered. The description adds two real behavioral facts beyond that: conversion is lossless and is mediated through the Universal Trust Schema (UTS). It does not say what happens on an unsupported pair or a malformed payload, so the disclosure is partial.

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 the verb and the format cartesian, then the UTS mechanism, then a pointer to the catalog endpoint. Nothing is wasted, though the closing doc link is a dangling reference whose content an agent cannot read from the definition alone.

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

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

There is no output schema, but for a pure transformation tool whose annotations declare read-only and idempotent behavior, the description gives enough to call it correctly: input formats, output formats, and the UTS mechanism. It would be stronger if it stated the shape of the returned JSON, but nothing critical 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 coverage is 100%, so 'from', 'to' and 'payload' are already documented at the field level, which sets the baseline at 3. The description adds a naming bridge (JWT/OAuth -> jwt, W3C VC -> w3c-vc) and reveals the adapter vocabulary, but it also advertises 9 formats while the schema lists only 6 accepted values, leaving the agent to resolve that gap itself.

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 (translate) and resource (credential) and enumerates the source/target format space, which is exactly what distinguishes it from the sibling marketnow_list_formats. An agent can tell this is a conversion tool rather than a discovery or verification tool without opening a schema.

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

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

The description implies you use this when you hold a credential in one format and need another, and it points to /api/trust?action=formats for the format catalog. It never names an alternative sibling (e.g. list_formats for discovery, verify_trust for validation) or states when NOT to use it, so routing guidance remains implicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: the PARSE→DECISION verification flow and the exact return payload (validity, format, trust score, issues).

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

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

Two sentences, front-loaded with the action and the accepted formats before the pipeline detail; the return summary is appropriately last. The parenthetical format list is dense but earns its place as scope 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 single-input verification tool with no output schema, the description covers input scope, processing pipeline, and return fields (validity, format, trust score, issues), which is enough for correct invocation. Only the sibling-routing guidance 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?

With a single parameter at 100% schema coverage, the schema already defines 'credential' as a JSON string or JWT. The description adds value by enumerating the accepted credential types (ATC v3, JWT/OAuth, W3C VC, MCP Card, A2A, EAT-AI, ZTA, SPIFFE SVID, X.509), which tells the agent which inputs are in scope.

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

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

States a specific verb (Verify) and resource (AI agent credential) and enumerates supported credential formats, so the agent knows exactly what class of input this handles. It also clarifies the pipeline scope by distinguishing the UTA 12-stage flow from Sentinel's skill-audit stages, though it never names the closest siblings (translate_credential, check_revocation) to draw the boundary.

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: the enumerated credential formats signal when this tool applies, and the Sentinel contrast scopes the pipeline. However, there is no explicit when-to-use versus when-not-to-use guidance and no routing to sibling tools such as check_revocation or translate_credential.

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