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

No annotations are present, so the description carries the full behavioral disclosure burden. It does not explicitly confirm the operation is read-only, mention permissions, default vhost behavior, or response characteristics. The only added behavior detail is the inclusion of both source and destination bindings, which is useful but minimal.

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, focused sentence with no filler. It front-loads the core action and adds the binding scope efficiently, earning its place in every clause.

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

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

There is no output schema, so the description should provide enough return context. It states exchange details and bindings are returned, but not what 'details' includes or how bindings are structured. It is adequate for a basic get operation but leaves some ambiguity about the exact response shape.

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%, with clear descriptions for both 'name' and 'vhost'. The tool description does not add parameter-level detail, but the baseline is satisfied because the schema already documents the parameters sufficiently.

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

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

The description uses a specific verb ('Get') and resource ('exchange details') and adds the scope of bindings, including both source and destination. This clearly differentiates it from list_exchanges and list_bindings, though it does not explicitly name those siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives like list_exchanges, get_queue, or list_bindings. There is no mention of conditions, exclusions, or trade-offs, leaving the agent to infer appropriate usage.

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

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

With no annotations, the description carries the disclosure burden. It does state what the response covers, and 'Get' implies a read-only operation, but it does not explicitly confirm no side effects or mention any caveats such as caching, rate limits, or auth requirements.

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

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

A single sentence that front-loads the operative verb and resource, then packs the most relevant return categories into a compact list. Every word earns its place.

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

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

For a zero-parameter, low-complexity overview tool, the description adequately conveys what the call returns. It could add an explicit note about being read-only or non-destructive, but nothing essential is missing for a competent agent to invoke it correctly.

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

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

The tool has zero parameters and the schema documentation coverage is effectively complete with an empty properties object. No parameter explanation is needed, so the baseline of 4 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 identifies a specific verb and resource: 'Get RabbitMQ cluster overview' and enumerates the returned categories (queue totals, connection counts, message rates, version info). This clearly distinguishes the tool from sibling tools that target individual queues, exchanges, or connections.

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 'cluster overview' provides clear context that this is the high-level summary tool versus the more specific sibling list/get tools. It lacks explicit exclusions such as 'for per-queue details, use get_queue,' but the intended use case is reasonably clear.

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

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

With no annotations provided, the description must carry the behavioral burden. The verb 'Get' and listing of stats implies a read-only operation returning details, but it does not disclose potential errors, whether any configuration might be affected, or how the statistics are sourced. It is adequate but minimal.

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 with zero filler: the resource and action come first, followed by a compact enumeration of the data returned. Every word earns its place.

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

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

For a simple two-parameter tool with fully documented schema parameters, the description covers the output categories sufficiently even though there is no output schema. It could add error or permission context, but nothing needed to invoke the tool correctly is missing.

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

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

Schema description coverage is 100%, and both name and vhost are already documented in the input schema. The description adds no new parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Get detailed stats'), identifies the resource ('a specific queue'), and enumerates the exact content returned (depth, rates, consumers, memory, policy, arguments). This clearly distinguishes it from list_queues, which would list queues, and get_exchange, which targets a different 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 phrase 'specific queue' conveys that the tool is for one known queue by name, which implies a different use case from the sibling list_queues. However, it does not explicitly state when to use it over alternatives or mention 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does convey that the tool scouts for problematic queues and surfaces potential issues, which suggests a read-only, non-destructive operation. However, it does not clarify whether the output is limited to unhealthy queues or includes all queues with health flags, nor does it mention default vhost behavior, pagination, or other side effects. No contradiction exists, but the behavioral picture is incomplete.

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

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

The description is compact at two sentences and front-loads the 'quick health check' framing before listing concrete criteria. The second sentence, 'Identifies potential issues,' is slightly redundant with the first, but the overall structure is efficient and easy to parse.

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

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

For a tool with two optional parameters and no output schema, the description gives the core purpose and criteria, which is sufficient for a basic understanding. However, it leaves gaps: whether results are only problem queues or all queues with status, and what the default vhost scope is. These are minor but relevant for an agent to interpret results 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 applies. Both parameters (vhost and minMessages) are already described in the schema, and the tool description adds no extra meaning about how they affect the health check. The description does not need to compensate because the schema documents them adequately.

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

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

The description clearly states the tool's function: a 'quick health check' that finds queues based on three specific criteria (no consumers, growing depth, high error counts). It identifies the resource (queues) and the condition of interest, and it is distinct from siblings like list_queues or get_queue, which simply list or retrieve without diagnostic intent.

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 'quick health check' implies a diagnostic, scan-style use case, but the description does not explicitly say when to prefer this tool over related siblings such as list_error_queues, list_consumers, or list_queues. There is no when-not-to-use guidance, so the usage context 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?

No annotations are provided, so the description carries the full burden. It only says 'List', which implies a read-only operation, but it does not disclose return structure, pagination, ordering, permissions, or error behavior. The description adds little beyond the basic operation name.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, and it is immediately clear what the tool does.

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 relatively simple 3-parameter tool, the description is minimally sufficient: it identifies the target and target type and indicates the resource being listed. However, with no output schema and no annotations, return-value context is missing, so an agent cannot fully anticipate what a successful call will produce.

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 does not add meaningful parameter details beyond what the schema already provides; it does restate that the target is a queue or exchange, but that is also present in targetType's enum and description.

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

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

The description uses a specific verb ('List') and resource ('bindings') and clearly scopes the operation to a particular queue or exchange. This differentiates it from sibling tools like list_queues and list_exchanges, which target different resources.

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

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

The description implies the tool should be used when you need bindings for a specific queue or exchange, but it never explicitly states when to prefer this over alternatives or when not to use it. Context is present, but exclusions and alternatives are absent.

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

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

With no annotations, the description carries the full burden. It discloses the filtering to active connections and the fields returned (client info, state, channel count), which is meaningful behavioral context. It does not mention pagination or result limits, but this is a simple read-only listing tool.

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

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

One economical sentence that front-loads the purpose and adds only meaningful detail about scope and output fields. Every word earns its place, with no repetition or filler.

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

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

For a simple parameterless listing tool, the description is nearly complete: it names the resource, the filtering condition, and the returned information. It could slightly expand on the exact output shape, but given the low complexity this is a minor gap.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. Baseline for a parameterless tool is 4, and the description appropriately focuses on what the tool returns rather than 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 ('List'), a concrete resource ('active RabbitMQ connections'), and the contained details ('client info, state, and channel count'). This clearly distinguishes it from the sibling tools, none of which target connections.

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 makes the tool's scope clear: it is for listing active RabbitMQ connections. It does not explicitly state when not to use it or name alternatives, but the sibling set has no overlapping connection-listing tool, so confusion is unlikely.

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

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

There are no annotations, so the description carries the behavioral burden. It does disclose that only "active" consumers are listed and that the result includes queue assignments, prefetch, and connection info, which is useful. However, it does not explain the default vhost scope, whether inactive consumers are always omitted, or any permission/visibility 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 description is a single focused sentence that front-loads the action and resource, then lists the returned fields. There is no redundancy or unnecessary detail.

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

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

This is a simple tool with one optional parameter, and the description provides enough about what is returned to make the call understandable. With no annotations and no output schema, a bit more about default vhost behavior or ordering would help, but for a straightforward read-only list operation the gap is minor.

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

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

The only parameter, vhost, is fully documented in the schema as "Filter by vhost" (100% schema coverage). The description adds no additional parameter semantics beyond this, so the 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 uses the specific verb "List" and names the resource (consumers) plus the included fields (queue assignments, prefetch, connection info). This clearly distinguishes it from sibling tools like list_connections and list_queues even without opening their schemas.

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

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

No guidance is given on when to use this tool versus alternatives, and no exclusions or prerequisites are stated. The name implies listing consumers, but the description does not say why an agent should choose it over list_connections for connection-level details or list_queues for queue-level 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?

With no annotations, the description carries the burden of behavioral disclosure. It adds that results include message counts, but its claim to find 'all' error queues conflicts with the schema's nonEmpty default of true, which means empty queues are hidden unless overridden; it also does not mention read-only status, permissions, or output 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 no filler; the primary action and resource are front-loaded and the second sentence adds a distinct operational purpose.

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

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

The tool is simple, has optional parameters only, and the description gives the central purpose and return value concept (message counts). However, the missing disclosure of the nonEmpty default makes the description materially incomplete for correct use when the agent wants to see empty error queues.

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 vhost and nonEmpty already have explanatory schema descriptions, so the baseline applies. The tool description adds no parameter-level meaning beyond saying counts are included.

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

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

The description states a clear verb ('Find') and a specific resource ('MassTransit _error queues') and states the output includes message counts, so an agent can tell this targets error queues rather than ordinary queues. It does not explicitly name sibling tools such as list_skipped_queues or peek_errors, so it misses the chance to sharpen differentiation.

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

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

'Helps identify services with unprocessed failures' gives a reasonable use case and implies it is for failure investigation. It does not mention when to prefer list_skipped_queues, list_queues, or peek_errors, nor does it state any 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does state that the tool lists exchanges with binding info and supports filters, which covers the basic operation. It does not mention pagination, result ordering, default scope, or response shape, though these gaps are less critical for a simple read-only list 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 two short sentences with no wasted words. The primary function is stated first, and the filter options are summarized immediately after. It is efficient and easy to parse.

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 straightforward read-only list operation with fully documented optional parameters, the description provides enough to select and invoke the tool correctly. It could be more complete by describing the output structure or pagination, but the tool is low complexity and the provided information is largely sufficient.

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 fully documents the three optional parameters. The description merely restates the filter options ('vhost, name pattern, or type') without adding meaning beyond what the schema provides, 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 action ('List'), the resource ('exchanges'), and the included information ('type and binding info'). It also names the available filters, making the tool's scope unambiguous and distinguishable from siblings like list_queues and get_exchange.

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

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

The description implies when to use the tool: when you need to list exchanges and can filter them. However, it provides no explicit guidance about when not to use it or when a sibling such as list_bindings or get_exchange would be more appropriate.

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

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

With no annotations, the description carries the behavioral burden. It discloses the output scope (queues with three metric types) and available filters, but does not mention pagination, rate limiting, default vhost behavior, or whether the list is complete. This is adequate for a simple read-only list, but not richly transparent.

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

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

Two short sentences pack the core purpose and filtering capability without fluff. The main resource and output fields are front-loaded, making it easy to scan.

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

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

The description supplies the primary output fields and filtering options, which is sufficient for a simple list tool with fully documented optional parameters. There is no output schema and no mention of pagination or sorting behavior, but these are minor gaps for a read-only listing operation.

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 parameter baseline is 3. The description's mention of filters by vhost and name pattern merely mirrors the schema's own parameter descriptions and adds no new semantic detail, and it omits the sortBy parameter entirely.

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: 'List queues' with the key included attributes: message depth, consumer count, and rates. This clearly distinguishes it from sibling tools like list_exchanges, list_connections, or get_queue, and the filters are also 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?

The description implies this tool is for listing queues and filtering, but it does not explicitly guide the agent toward alternatives such as get_queue for single-queue detail or peek_messages for message content. The usage context is clear but no exclusions or alternative routing are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does indicate that the tool returns message counts and explains why skipped queues matter, but it does not explicitly state that this is a read-only operation or mention default filtering behavior (e.g., nonEmpty defaults to true). The behavior is implied but not fully transparent.

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

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

The description is two sentences with no filler. The core action and output are front-loaded in the first sentence, and the second sentence adds valuable diagnostic context. Every word earns its place.

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

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

For a simple list tool with two optional parameters and no output schema, the description is largely sufficient: it states what is returned (message counts) and why the tool matters. Minor gaps include not describing the return shape or explicit vhost behavior, but the schema covers the parameters and the use case is clear.

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 both vhost and nonEmpty are already well-documented in the schema. The description does not add any additional parameter-level meaning beyond what the schema provides, making the baseline score 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 uses a specific verb ('Find all') and identifies a precise resource ('MassTransit _skipped queues') while adding output detail ('with message counts'). This clearly distinguishes it from sibling tools like list_queues and list_error_queues, which target different queue categories.

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 second sentence ('Skipped messages indicate routing or serialization issues') gives a clear diagnostic context for when to use this tool. However, it does not explicitly name alternative tools or state when not to use it, leaving some inference to the agent.

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

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

With no annotations, the description carries the full burden. It does disclose that messages are parsed and what fields are returned, but it does not explicitly state that peeking is non-destructive or what happens with non-MassTransit/malformed messages. The word 'peek' implies read-only, but an explicit statement would be more transparent.

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

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

A single, information-dense sentence that front-loads the core purpose and then lists the specific returned fields. There is no filler, redundancy, or unnecessary detail.

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

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

The description covers the essential invocation context: what the tool does, what kind of queue it targets, and what the returned content includes. Since there is no output schema, the explicit field list is valuable. It could be slightly more complete with a note about non-destructive behavior or behavior on non-MassTransit messages, but it is sufficient for a straightforward peek tool.

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

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

Schema description coverage is 100%, and the description does not add meaningful parameter-level details beyond what the schema already states. The description's mention of parsed fault details is behavioral context rather than parameter semantics, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Browse') and names the exact resource ('error queue messages') with a distinctive feature set: parsed MassTransit fault details (exception type, message, stack trace, original payload, source host). This clearly distinguishes it from siblings like list_error_queues (which lists queue names) and peek_messages (which would not provide MassTransit-specific parsing).

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 context is implied: this is for browsing error-queue messages with MassTransit fault detail parsing. However, it does not explicitly state when to choose this tool over peek_messages or list_error_queues, nor does it mention when not to use it. A more explicit routing statement would strengthen this dimension.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the two most important behaviors: the operation is non-destructive (no consumption), and MassTransit envelopes are parsed when detected, which tells the agent that returned message content may be transformed. It omits minor details like ordering guarantees or empty-queue behavior, but the critical traits are covered.

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

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

Two sentences with zero waste. The core purpose and the non-destructive guarantee are front-loaded in the first sentence, and the MassTransit detail earns its place in the second. Every word adds information.

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

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

The description is sufficient for invoking the tool: it names the action, the target resource, and the safety profile, while the schema covers parameters. However, with no output schema present, the description does not disclose what the response looks like (message bodies? headers? count?), and it does not cover failure behavior such as nonexistent queues. These are noticeable gaps given the absence of an output schema.

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

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

Schema description coverage is 100%, with all three parameters (queue, count, vhost) documented in the schema including defaults and bounds. Per the rubric, this yields a baseline of 3; the description adds no parameter-specific meaning beyond the schema, so the baseline stands.

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 ('Browse') with a clear resource ('messages in a queue') and adds the key qualifier 'without consuming them (non-destructive)', which precisely scopes the operation. However, it does not explicitly differentiate from the sibling peek_errors or get_queue, so an agent must infer the boundaries from the sibling names rather than the description.

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 non-destructive framing implies the use case: inspect queue contents without side effects. But there is no explicit guidance on when to prefer this tool over alternatives such as peek_errors (for error queues) or get_queue (for queue statistics), and no stated exclusions or conditions.

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