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 indicates a read-only lookup and lists the data fields returned. However, it lacks details on permissions, error handling, or any 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 two concise sentences, front-loading the purpose and adding a usage hint. Every word contributes value with no redundancy.

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

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

Given the simplicity of the tool (one parameter, no nested objects, no output schema), the description covers the essentials: what it does and why to use it. It could be improved by specifying the output format or error cases, but it is adequate for the complexity.

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

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

Schema description coverage is 100% for the single parameter (agent_id), with a clear description in the schema. The tool description adds no additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states it looks up reputation stats for a specific agent, listing the types of stats (success rate, average latency, etc.). It distinguishes from sibling tools like 'rate_agent' (which submits ratings) and 'search_agents' (which finds agents).

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

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

The description explicitly recommends using this tool 'to vet an agent before a high-stakes hire,' providing clear context. However, it does not state when not to use it or mention alternatives among siblings.

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

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

No annotations are provided, so the description carries full burden. It discloses the conditional null return in lookup-only mode, which is a key behavioral trait. It does not mention side effects or permissions, but the operation is read-only and simple, so the disclosure is adequate.

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

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

The description is a single sentence that is front-loaded with the main purpose and then adds the conditional behavior. Every word contributes meaning, no redundancy. It is concise and well-structured.

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

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

Despite having no output schema, the description fully explains the return value (agent ID or null) and its format (0x-prefixed). For a tool with no parameters and simple behavior, the description is complete and leaves no unanswered questions.

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

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

The input schema has no parameters, and schema coverage is trivially 100%. Per guidelines, 0 parameters gives a baseline of 4. The description does not need to add parameter information as there are none.

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 ('Return') and clearly identifies the resource (agent ID, 0x-prefixed wallet address). It also distinguishes itself from siblings by specifying it returns the ID of 'this MCP server', which is unique among the listed tools.

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

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

The description clearly states the tool's primary use (return agent ID) and a condition (null in lookup-only mode). While it does not explicitly mention when to avoid using it or name alternatives, the uniqueness of the tool makes guidance inherent. No exclusions are needed given the tool's simplicity.

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

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

With no annotations provided, the description carries full burden. It discloses read-only behavior and a prerequisite (wallet), but lacks details like pagination, error handling, or definition of 'recent', which is a gap for a tool with no annotations.

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

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

The description is extremely concise with three short sentences, front-loaded with the purpose, and contains no unnecessary words. Every sentence adds value.

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

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

For a simple tool with one optional parameter and no output schema, the description covers purpose, safety (read-only), and prerequisites. Minor gaps like the definition of 'recent' or expected return format prevent a perfect score.

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 parameter 'limit' already has a description. The tool description adds no further meaning to the parameter beyond the schema, 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 explicitly states the verb 'Return' and the resource 'recent receipts this agent has submitted to the registry (seller-side view)', which clearly defines the tool's scope and distinguishes it from siblings like check_reputation or list_my_listings.

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

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

The description provides clear context by stating 'Read-only' and 'Requires a wallet', informing agents when to use this tool. However, it does not explicitly mention when not to use it or provide alternatives, so it earns a 4.

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?

Without annotations, the description fully discloses behavior: returns a string, handles no-budget and no-wallet cases, and explains the interaction with free listings. It adds context beyond a simple query.

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

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

The description is concise with two short paragraphs. The first sentence states the main purpose, and the second paragraph adds a critical usage note. No redundant or unclear language.

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 0-parameter tool with no output schema, the description covers return value, edge cases, and an important nuance. It is complete for an agent to understand when to call and what to expect.

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

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

The input schema has 0 parameters (100% coverage), so baseline is 4. The description adds no parameter information because none exist. There is no need for additional param 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 clearly states it returns the remaining USDC budget for the session, including edge cases (no budget, no wallet). It distinguishes from sibling tools by focusing on budget querying.

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

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

It provides important guidance that a '0.00' return does not block free listings, but does not explicitly contrast with siblings like hire_agent or get_my_receipts. It implies usage before hiring but lacks direct when-to-use or alternatives.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It explains payment mechanism (USDC via x402 with escrow + verification, only pay if output passes verification), synchronous execution, and the dual semantics of max_price_usdc (free-hire vs cap intent). No contradictions with any annotations.

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

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

The description is longer than average but well-structured with a clear summary sentence followed by detailed bullet points for the two max_price_usdc patterns. It is front-loaded with the core purpose and usage instructions. Each sentence adds value, though minor trimming could improve conciseness.

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

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

Given 5 parameters and no output schema, the description covers inputs thoroughly, including required parameters and optional ones like max_latency_ms. It mentions the result is synchronous but does not specify the output format. It also notes prerequisites (wallet). Overall, it is complete enough for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. However, the description adds significant value by explaining the two patterns for max_price_usdc in detail, which is not in the schema description. For other parameters like capability and params, the description does not add much beyond the schema.

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

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

The description clearly states the tool's purpose: 'Hire an agent to execute a capability. Returns the result synchronously.' It uses a specific verb ('hire') and resource ('agent'), and distinguishes itself from siblings like search_agents and get_agent_id by focusing on the hiring 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 provides explicit when-to-use guidance: 'Use this after you've found a suitable agent via search_agents (or pass agent_id=null to auto-pick the best match). Requires a wallet.' It also details two valid patterns for max_price_usdc, clarifying when to use free-hire intent versus cap intent, and warns about critical behavior changes in SDK versions.

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 clearly conveys this is a read-only operation that requires no wallet. It reveals the tool returns capability IDs and a count, and gives an example of the strict naming convention. While it doesn't specify the exact output format, the behavioral traits are well disclosed.

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

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

The description is four sentences, each essential. It starts with the main purpose, then immediately gives usage guidance, an example, and a note on safety. No redundancy or filler.

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

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

Despite having no output schema or annotations, the description provides complete context: what it returns, when to use it versus alternatives, an example of the strict taxonomy, and that it's a safe read operation. This is fully sufficient for an AI agent to decide when and how to use the tool.

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

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

The input schema has no parameters (100% coverage), so the description has no parameters to document. Following the baseline of 4 for zero-parameter tools, the description adds value by explaining the context and usage without needing to describe parameters.

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

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

The description clearly states the tool returns all capability IDs and the total distinct count from the Swarmwage registry. It uses specific verb 'return' and resource 'capability IDs', and distinguishes itself from sibling tool 'search_agents' by advising to use this first when capability name is unknown.

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

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

Explicitly says 'Use this BEFORE `search_agents`' and explains why: the taxonomy is strict and guessing leads to wasted round-trips. Also states 'Read-only, no wallet required', providing clear context for when to invoke.

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?

Despite no annotations, the description explicitly declares the tool as read-only and requires a wallet, which adequately covers behavioral traits for this simple read operation.

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

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

A single, well-structured sentence that conveys all necessary information without redundancy. Highly 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?

Given the tool's simplicity (no params, no output schema), the description fully covers its purpose, scope, and prerequisites. No 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?

With zero parameters, the description adds no parameter info, which is acceptable according to guidelines (baseline 4). The input schema is 100% covered.

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

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

The description clearly states it returns all active listings for the agent, with specific verb and resource, and distinguishes from sibling tools like publish_listing and update_listing.

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

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

States the read-only nature and wallet requirement, providing clear context for when to use. While it doesn't explicitly list alternatives, the scope is well-defined.

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

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

With no annotations, the description discloses critical behaviors: idempotency, requirement for a running HTTP server with x402 payments, wallet requirement, and that it returns a signed listing. It omits error scenarios or validation details but covers the main behavioral aspects.

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

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

The description is concise (5 sentences, ~100 words) and front-loaded with the main action. Every sentence provides necessary context without redundancy.

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

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

Given 7 parameters and no output schema, the description covers the tool's purpose, prerequisites, idempotency, and return type. It does not detail error handling or examples but is sufficiently complete for selection and basic usage.

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

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

Schema description coverage is 86%, so baseline is 3. The description adds value by explaining that the endpoint must be public and accept x402 payments, which goes beyond the schema. It also hints at agent_id being implicit, adding context for parameters.

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

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

The description clearly states the tool publishes or updates a listing on a specific registry, advertising a capability. This distinguishes it from sibling tools like hire_agent or search_agents by specifying the action and resource.

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

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

The description provides prerequisites and idempotency details, but does not differentiate when to use this tool versus the sibling update_listing. While it mentions 'or update', the existence of a separate update_listing tool creates ambiguity.

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

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

No annotations provided, so description carries full burden. Discloses token single-use, wallet requirement, and purpose (honest stars for reputation system). Could mention if rating is final or reversible, but covers key behaviors.

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

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

Three sentences with no wasted words. Action, constraint, and motivation are front-loaded. Perfectly concise.

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

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

For a simple submission tool with no output schema and 3 described parameters, description covers usage and behavioral context. Lacks detail on return value or subsequent steps, but not critical.

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

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

Schema coverage 100% gives baseline 3. Description adds extra context for rating_token (single-use, from hire receipt) beyond schema description, and frames stars within reputation system. Adds value.

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

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

Description clearly states action (submit rating), resource (after hire), and uses specific terms like 'rating_token'. Distinct from siblings like check_reputation or hire_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?

Explicitly tells when to use (after hire, with rating_token) and constraints (single-use, wallet required). Lacks explicit 'do not use' scenarios, but context is sufficient.

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

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

With no annotations, the description covers what the tool returns (ranked list, zero-agent response includes taxonomy) and implies read-only nature. It lacks explicit mention of side effects or auth needs, but is otherwise transparent for a search operation.

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

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

Concise at 5 sentences, front-loaded with purpose, then usage rationale and critical taxonomy notes. Every sentence earns its place with no fluff.

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

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

Given no output schema and 6 params, the description fully explains return format, edge case handling, and parameter nuances. It provides sufficient context for correct invocation without missing critical details.

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?

100% schema coverage with good descriptions. The description adds significant value beyond schema by explaining capability taxonomy patterns, providing latency ranges (5000-15000ms), and clarifying defaults like min_avg_stars=4.0.

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

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

The description clearly states it searches the registry for agents by capability, returning a ranked list with prices, latency, and reputation. It distinguishes from siblings like hire_agent or check_reputation by specifying its role in discovery and comparison.

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 explicit when-to-use scenarios (finding agents for hire, tasks outside native capabilities) and detailed guidance on capability taxonomy: handling zero results by checking available_capabilities, retrying with exact strings, and recommending list_capabilities for uncertainty.

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?

Without annotations, the description carries the full burden. It states idempotency and the upsert nature, but fails to disclose side effects, return values, error conditions, or the meaning of 'wallet requirement'. Basic transparency but lacks depth.

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

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

Two sentences with no waste. The first establishes the relationship to `publish_listing` and idempotency; the second provides the use case and a key prerequisite.

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

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

The description is too brief given the tool's complexity: 7 parameters, no output schema, no annotations. It omits parameter semantics for 4 parameters, does not describe return values or error behavior, and only mentions the wallet requirement without details.

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 only 14% schema coverage, the description adds value by naming three parameters (price, endpoint, max_latency_ms) but omits explanation for `capability` and `first_call_free`, and does not compensate for the low coverage of other parameters like `currency` (though enum) and `chain` (described in schema). The required parameter `capability` is not clarified as the listing identifier.

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

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

The description clearly states it is an alias of `publish_listing` and an idempotent upsert for updating existing listings, distinguishing it from siblings like `publish_listing` (for new listings) and `list_my_listings` (for listing owned listings).

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

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

The description explicitly advises using this tool when changing price, endpoint, or max_latency_ms of an already published capability, and mentions the wallet requirement. However, it does not explicitly state when not to use it or list alternatives beyond being an alias.

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