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

With no annotations, the description carries the full behavioral burden. It discloses that the message will be deleted, but omits critical context around ackmode/requeue semantics, permissions, empty-queue behavior, and how the default ack_requeue_true may conflict with the stated deletion.

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 one front-loaded sentence with a parenthetical effect note; it is efficient and avoids waste. It lacks structural elaboration, but that is not required for 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?

For a 5-parameter mutation-like consume operation with no output schema and no annotations, the description is too sparse. It does not explain return values, empty-queue handling, or the impact of ackmode on whether the message is actually deleted.

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 parameters are already documented in the schema. The description adds no parameter-level meaning beyond noting one message, which aligns with the default count of 1 and maximum of 1.

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

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

States a specific verb+resource: consuming one message from a queue, and adds the destructive effect in parentheses. This clearly distinguishes it from siblings like publish_message or list_queues, though it does not name an explicit alternative.

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 or when-not-to-use guidance relative to alternatives such as list_queues or publish_message. Usage is only implied by the tool name and purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about mutation semantics: idempotency, what happens if an identical binding exists, required permissions, or failure modes. A single declarative sentence about creation is not sufficient for a write operation with zero annotation coverage.

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 short, front-loaded sentence with no padding or redundancy. Nothing could be removed without losing the core meaning.

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 5-parameter mutation tool with no annotations and no output schema, the description is far too thin: it omits preconditions, error behavior, and the destination_type nuance. The agent is left to infer everything beyond the bare action from the schema alone.

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

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

Schema description coverage is 100%, so every parameter (vhost, source, destination, routing_key, destination_type) is already documented in the schema, making 3 the baseline. The description adds no format hints or examples, and its 'exchange to queue' framing actually conflicts with the destination_type enum that allows queue or exchange.

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 (交换机到队列的绑定), which is enough to distinguish it from siblings like delete_binding and list_bindings. However, it narrows the scope to exchange→queue while the schema's destination_type enum also permits exchange→exchange, so the stated purpose is slightly misleading about the actual capability.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites such as the source exchange and destination queue needing to already exist. The sibling set (create_exchange, create_queue, delete_binding) makes routing guidance genuinely useful and it is entirely absent.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure, yet it says nothing about idempotency, what happens if the exchange name already exists, permission/auth requirements, or error behavior. For a mutating create tool with zero annotation coverage, this is a serious gap.

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?

Only five characters long – not wasteful, but underspecified rather than concise. There is no front-loaded useful information because there is essentially no 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?

A four-parameter mutation tool with no annotations and no output schema needs the description to explain conflict handling, durability implications, and vhost resolution. None of that is present, leaving the definition inadequate for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents name, type, vhost, and durable. The description contributes nothing beyond that, but per the rubric a high-coverage schema sets the baseline at 3.

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 '创建交换机' is a literal restatement of the tool name create_exchange, which the rubric classifies as tautology. It names a verb+resource but adds no scope, target system, or sibling differentiation beyond the name itself.

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 indication of when to create an exchange versus using create_queue, create_binding, or binding an existing exchange. No prerequisites, ordering, or context is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses only that a queue is created. It does not state what happens on a name collision, whether creation is idempotent, what permissions are required, or the effect of the durable/vhost defaults.

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 four-character phrase, which is maximally concise and front-loaded but borders on under-specification rather than efficient brevity. It contains no wasted words but also almost no 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 mutation tool with three parameters, no annotations, and no output schema, the description omits the vhost/durable defaults' implications and any note about name uniqueness or required permissions. It is not sufficient for an agent to call this tool correctly in edge cases without opening the 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%, and each parameter (name, vhost, durable) already has a description and defaults in the schema, so the baseline of 3 applies. The description itself adds no meaning beyond the schema.

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

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

创建队列 states a clear verb+resource, so an agent immediately knows this creates a queue. However, it says nothing to distinguish it from the many sibling create_* tools (create_user, create_exchange, create_vhost, create_binding) beyond its resource name, and the description is essentially a restatement of the tool name.

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

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

There is no guidance on when to use this tool, no prerequisites (e.g. the vhost must exist), and no mention of alternatives such as create_exchange for other entity types. The agent must infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: no permission requirements, no uniqueness behavior if 'name' already exists, no note on irreversibility, and no indication that 'password' is a sensitive credential field. For a mutating tool this is a serious omission.

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

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

The description is a single four-character phrase — not wasteful in the sense of padding, but under-specified rather than concise. There is no front-loaded structure because there is essentially no content to structure.

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

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

For a mutating tool with no annotations and no output schema, the description should at minimum cover permissions, failure modes, or credential handling. The schema does document all three parameters, which prevents this from being a bottom score, but the behavioral gap remains significant.

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 name, tags (including an example values hint), and password each documented in the schema itself. The description adds nothing beyond the schema, so the baseline of 3 applies for adequately documented parameters.

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

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

The description '创建用户' is a direct restatement of the tool name create_user — it names the verb and resource but adds no scope, constraints, or distinguishing detail. It does not differentiate this tool from any sibling in a 20-tool set that includes delete_user, list_users, create_queue, etc.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as list_users or delete_user. The implied usage (call it when a new user is needed) is inferable only from the name, not from the description text.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation (creation) but discloses nothing about permissions required, whether the name must be unique, idempotency on repeat calls, or default vhost existence — all material for a create 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 short phrase is front-loaded and contains no filler, which is structurally clean. But it is terse to the point of under-specification for a mutating tool rather than genuinely efficient communication.

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 create tool with full schema coverage, the schema covers the inputs adequately. But with no annotations and no output schema, an agent receives no information about side effects, error conditions (e.g. duplicate name), or what the call returns — gaps the description should have filled.

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 both parameters (name, description) documented in the schema itself, including the default for description. The description adds nothing beyond the schema, so baseline 3 applies.

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

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

"创建虚拟主机" names a specific verb (create) and resource (virtual host), so the basic action is unambiguous. However, it offers no differentiation from siblings such as delete_vhost or the other create_* tools beyond the noun itself, and the title is null so nothing else disambiguates.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites, ordering relative to create_exchange/create_queue, or conditions like name collisions. An agent gets only the verb and must infer context entirely from the name.

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

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

No annotations are provided, so the description carries the full disclosure burden. It is an irreversible mutation, yet nothing is said about permissions required, whether deletion fails silently if the binding is absent, or whether the change is recoverable — the single phrase adds no behavioral context beyond the verb itself.

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 short sentence with no filler, and the action is front-loaded. It is efficient, though it errs toward under-specification rather than true conciseness.

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

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

A destructive 5-parameter tool with no annotations and no output schema needs the description to explain effects, failure modes and permissions. One bare phrase leaves all of that uncovered.

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 every parameter (vhost, source, destination, routing_key, destination_type) is documented in the schema, so the baseline is 3. The description adds no syntax, default, or matching-semantics detail beyond what the schema already supplies.

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

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

The description states a specific verb+resource ('删除...绑定') and even names the endpoints (交换机到队列), so an agent knows what is removed. It does not, however, distinguish itself from siblings like delete_queue or delete_exchange, nor does it acknowledge that destination_type also permits exchange targets.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g. that the binding must exist) and no reference to alternatives such as list_bindings for identifying the binding first. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive, likely irreversible mutation, but the description says nothing about whether dependent bindings are removed, whether the exchange must be empty, what permissions are needed, or what the response is.

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?

It is a single short phrase with no wasted words, so it is not bloated. However, brevity here reflects under-specification rather than disciplined conciseness, since nothing is front-loaded beyond the bare action.

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 destructive two-parameter tool with no annotations and no output schema, the description is far too thin. An agent gets no information about side effects, safety, or failure conditions that would let it invoke this confidently.

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 ('name' and 'vhost') are documented in the schema with a default noted for vhost. The description adds no meaning beyond that, 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?

The description gives a specific verb and resource ('删除交换机' / delete exchange), which is unambiguous about what the tool does. It does not explicitly contrast itself with siblings such as delete_queue, delete_vhost, or delete_binding, but the resource noun is specific enough for an agent to distinguish it.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisite checks, and no warning about the destructive nature of the operation. The agent must infer everything from the verb alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not state that the operation is destructive and irreversible, what permissions (management/configure on the vhost) are required, what happens to unconsumed messages, or how errors surface when the queue does not exist.

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 four-character fragment with nothing wasted but also nothing earned; it is under-specified rather than concise. There is no front-loaded scope or caveat because there is no content at all.

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 destructive, unannotated tool with no output schema and no sibling routing, the description leaves the agent without the minimum needed to call it safely. It says nothing about irreversibility, vhost scoping behavior with the default "/", or failure modes.

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%: both "name" (队列名称) and "vhost" (default "/") are documented in the schema itself. The description adds no semantics beyond that, 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?

"删除队列" restates the tool name delete_queue verbatim, so it conveys no information the agent did not already have from the identifier. It names a verb and resource, but as a description it is a tautology rather than a differentiation from siblings like create_queue, delete_exchange, or delete_vhost.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no mention of alternatives. For a destructive operation on a messaging broker this is a serious omission: the agent is not told whether the queue must be empty, whether consumers must be disconnected first, or which sibling (e.g., a purge or a binding deletion) would be the safer alternative.

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

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

No annotations provided, so the description carries the full burden of behavioral disclosure. '删除用户' (delete user) states only the action and resource; it says nothing about whether deletion is permanent, what happens to associated resources (queues, bindings, permissions), or whether special permissions are required. This is severely inadequate for a destructive operation.

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

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

The description is extremely short—just two words. While it avoids verbosity, it is under-specified rather than concise; the brevity reflects missing information rather than efficient communication.

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 destructive tool with no annotations, no output schema, and only one parameter, the description is completely inadequate. It fails to mention irreversibility, error handling, or any behavioral context that an agent needs before invoking a delete 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 single parameter 'name' is fully documented in the schema. The description adds no parameter detail, but baseline 3 is appropriate when schema coverage is high.

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 ('删除' = delete) and resource ('用户' = user). The sibling set includes create_user, list_users, but the description doesn't differentiate against them beyond the obvious action; still, 'delete user' is unambiguous among 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?

No when-to-use guidance, no prerequisites, no alternatives mentioned. An agent must infer from the name alone that deletion is irreversible and appropriate for removing a user, but nothing in the description provides that context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about irreversibility, whether the vhost must be empty, required permissions, or side effects on queues/exchanges bound to the vhost — critical gaps for a destructive 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?

It is a single front-loaded phrase with zero waste, but it is under-specified rather than genuinely concise — brevity comes at the cost of all operational context.

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 destructive tool with no annotations and no output schema, the description is far too thin: it omits reversibility, preconditions (e.g., empty vhost), and impact on dependent resources. An agent has almost nothing to reason about before invoking it.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents the required 'name' field. The description adds no additional meaning (e.g., name format or constraints), which matches the baseline 3 for full-coverage schemas.

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

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

States a specific verb+resource (删除虚拟主机 = delete virtual host), which lets an agent distinguish it from the sibling create_vhost and list_vhosts without opening the schema. It is clear but contains no explicit sibling differentiation or scoping detail.

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 names no alternative. An agent must infer everything from the tool name and the surrounding sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether this is a read-only operation, whether it requires specific permissions, what it returns, or how it behaves. It only restates the purpose, leaving the agent without operational context.

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

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

The description is a single short sentence, front-loaded with verb and resource. It is concise and waste-free, though it may be overly terse for a tool intended to be selected among many siblings.

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 annotations, no output schema, and a crowded sibling environment, the definition is incomplete. An agent needs to know what 'cluster status' includes, whether it is safe to call frequently, and how it differs from other read tools. The description does not address these gaps.

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

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

The tool has zero parameters, so the baseline is 4. The description cannot add parameter meaning beyond that, and it correctly implies a no-argument call. No further detail is needed.

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

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

The description states a specific verb+resource ('获取' + 'RabbitMQ集群状态'), so the purpose is identifiable. However, it lacks sibling differentiation – the sibling list has many 'list_' and 'get_' tools, and this description does not explain how it differs from list_queues, list_connections, etc. It is adequate but vague about 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?

There is no when-to-use guidance. The description does not explain when an agent should retrieve cluster status versus using another sibling tool, nor does it mention any prerequisites or exclusions. With a large set of sibling tools, this omission is notable.

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

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

No annotations are provided, so the description carries the full behavioral burden. '获取' implies a read operation, but the description says nothing about permissions, error behavior when the exchange does not exist, or whether the default vhost affects the lookup. This is a significant gap for a tool with zero annotation coverage.

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 short phrase with zero wasted words and the action front-loaded. Its brevity is not verbosity, but it tips into under-specification for a tool with siblings it must be distinguished from.

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 tool with no output schema, the description still omits what is returned (e.g. exchange type, durability, bindings) and what happens on a missing name. It is technically callable but leaves the agent guessing about the result and failure modes.

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 'name' and 'vhost' (with its default '/') are already fully documented in the schema. The description adds no syntax, format, or naming-convention detail beyond that, so the baseline 3 applies.

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

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

The phrase '获取交换机信息' names a specific verb (获取/get) and resource (交换机/exchange), so the basic action is identifiable. However, it does nothing to distinguish itself from the sibling list_exchanges, which an agent could easily confuse with a single-exchange lookup. Adequate but not differentiating.

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

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

There is no guidance on when to use this tool versus list_exchanges or get_cluster_status, and no mention of prerequisites such as needing an existing exchange. Usage must be entirely inferred from the name and required 'name' parameter.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only the vhost scoping; it says nothing about ordering, pagination, size limits, permission requirements, or whether deleted/nonexistent vhosts error. For a list tool with zero annotation coverage this is thin.

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 stating the resource and its scope, with no wasted words.

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?

Minimally viable for a simple one-parameter list operation, but with no annotations and no output schema the description should mention return shape or scoping behavior to be fully complete.

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

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

Schema coverage is 100% and the single parameter 'vhost' is fully documented with type and default. The description adds nothing beyond what the schema already conveys, 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?

States a specific verb+resource: 'list all bindings under the specified vhost.' A reader can tell it enumerates bindings scoped to a vhost, distinguishing it from create_binding/delete_binding. However, it does not explicitly say how it differs from list_vhosts or other list_* siblings, so it falls short of a 5.

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

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

There is no when-to-use guidance beyond the operation itself. No mention of when to prefer list_bindings over querying exchanges or queues, and no stated prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says only 'list all connections'. It does not state that the operation is read-only/non-mutating, whether it paginates, its scope, or what happens on a large broker. Minimal disclosure for a tool with zero structured safety hints.

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 terse phrase that is front-loaded and wastes nothing. It is arguably under-specified rather than over-long, but as raw conciseness it is 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?

For a zero-parameter list tool with no output schema and no annotations, the description is minimally adequate: it names the resource but omits return contents, scope, and any read-only assurance. Complete enough to call, but not enough to call confidently.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly implies a no-argument full listing, consistent with the empty schema.

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

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

The description states a clear verb+resource ('列出所有连接' / list all connections), so the agent knows it retrieves the full connection list. It does not explicitly differentiate itself from sibling list tools like list_vhosts or list_queues, but the distinct resource name is sufficient to disambiguate. No sibling routing or scope notes are offered.

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

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

There is no guidance on when to use this tool versus alternatives, no preconditions, and no note about scope (e.g., per-vhost vs cluster-wide). For a broker with many sibling list tools, this leaves the agent to infer context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. '列出' implies a read-only, non-mutating call, but nothing is said about pagination, result size, empty-vhost behavior, or what a missing vhost returns.

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 tight sentence with no waste and the scoping qualifier front-loaded. Nothing superfluous, though nothing extra is offered either.

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 list tool with no output schema, minimal prose is defensible. Still missing is any notion of result volume, ordering, or whether the list is vhost-scoped recursively, which an agent would need before relying on 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 description coverage is 100% and the single vhost parameter is documented in Chinese with its default ('/'), so the schema does the work. The description adds only the meaning of the scope (exchanges vs other resources under the vhost), which is the baseline-3 case.

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

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

Names a specific verb (列出/list) and resource (交换机/exchanges) plus the scoping dimension (指定虚拟主机/specified vhost), so an agent knows exactly what is returned. It does not differentiate from siblings like list_queues or list_bindings, but the resource noun itself is distinguishing.

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

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

No guidance on when to call this versus alternatives such as get_exchange (single exchange) or list_bindings. The only hint is the implicit 'list all in scope' reading, which is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only enumeration but says nothing about permissions/authentication requirements, whether results are paginated or complete, or how it behaves when the vhost has no queues or does not exist.

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 identifies verb, resource, and scope with no filler. It is appropriately sized for so simple a tool, though it offers nothing extra.

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 tool with full schema coverage and no output schema, the description is minimally sufficient. It nonetheless omits behavioral context that annotations would normally supply, such as permission requirements and whether the listing is paginated or complete.

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

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

Schema description coverage is 100% and the single vhost parameter already documents its name and default ('/'), so the description only echoes the scope. Baseline 3 applies since the schema does the parameter-level work.

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

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

States a specific verb+resource (列出...队列) with scope limited to a virtual host, which cleanly separates it from siblings like list_exchanges, list_users, and list_bindings. It does not, however, explicitly name an alternative or note the broader list_* family.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., does the vhost need to exist?), and no statement about when not to use it. The agent must infer the context entirely.

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

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

With no annotations provided, the description carries the full behavioral burden but discloses nothing beyond the basic operation — no indication of result format, pagination, ordering, or any permission 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 short clause with zero waste, front-loaded with the verb and resource. Nothing extraneous.

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-param list tool with no output schema and no annotations, the description is minimally adequate but omits what is returned (e.g., user identifiers or a count), leaving the agent to infer the 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?

The schema has zero parameters, which sets the baseline at 4. There is nothing for the description to clarify about inputs.

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

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

The description states a specific verb and resource ('list all users'), which clearly distinguishes it from write siblings like create_user and delete_user. It is unambiguous, though it adds no scope detail beyond the bare operation.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites, and no exclusions. The usage is only implied by the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. "列出所有" weakly implies a read-only, unfiltered listing, but there is no mention of authentication needs, pagination, result volume, or what is returned. For a tool with zero annotation coverage this is a significant gap.

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 short phrase with no wasted words and is inherently front-loaded. It is efficient, but its brevity reflects under-specification rather than disciplined conciseness. Appropriate size for a trivial tool, but it earns little credit for content.

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

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

There is no output schema and no annotations, so the description is the only source of information about the tool's behavior and results. It says nothing about the return shape, pagination, or ordering, leaving the agent without the context it needs to interpret results.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to clarify. Per the baseline for parameterless tools, this scores 4 by default; the description does not need to compensate for anything here.

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 phrase "列出所有虚拟主机" does state a verb (list) and resource (virtual hosts) with an explicit "all" scope, so the purpose is discernible. However, it is essentially a translation of the tool name and adds no differentiating detail beyond it. It is adequate but minimal, landing at the minimum-viable level.

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

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

There is no guidance on when to use this tool, what prerequisites exist, or how it relates to siblings such as get_cluster_status or list_queues. The agent must infer usage entirely from the name. No exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Publish' implies a write/side-effecting operation, but nothing is said about delivery guarantees, persistence, whether an exchange must pre-exist, or what happens on failure. For a mutation tool with zero annotation coverage this is a significant gap.

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 short sentence with zero waste, front-loaded on the action. It is arguably too terse for its job, but it is not padded or poorly 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?

For a 5-parameter, side-effecting tool with no annotations and no output schema, the description omits what an agent needs: whether the exchange must exist, vhost semantics, confirmation of delivery, and error behavior. The schema covers inputs but nothing covers operation behavior.

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

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

Schema description coverage is 100%, so all five parameters including defaults for vhost, exchange and content_type are already documented in the schema. The description adds nothing beyond that, which is the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb and resource: publish a message to an exchange. An agent can distinguish it from consume_message and the create_*/list_* siblings, though it never names an alternative explicitly. The purpose is clear but the sibling differentiation is left to inference.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g. the exchange must already exist, how vhost selection interacts with the default), and no statement of when to prefer consume_message or another tool. Only the bare action is given.

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