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

There are no annotations to disclose safety or side effects, so the description carries the full burden. It simply says 'Modify settings' without explaining the impact of the dry_run and confirm_write parameters, whether changes are reversible, or whether special permissions are needed. This is a significant gap for a mutation 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 a single concise sentence with no verbosity, which is appropriate for conveying the core purpose. However, it is under-specified and lacks any structural information about parameters or usage, making it minimally concise but not effectively 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?

Given the tool has three undocumented parameters, no annotations, and an output schema whose content is unexplained, the description is far from complete. The agent cannot safely or correctly invoke the tool without knowledge of payload format, dry_run semantics, or confirm_write behavior. This is inadequate for a tool with this complexity.

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

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

The input schema has three parameters (dry_run, payload, confirm_write) with 0% schema description coverage, and the description does not mention any of them. The agent receives no help understanding the payload structure, the purpose of dry_run, or how confirm_write affects execution. The description fails to compensate for the missing schema descriptions.

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 'Modify' and names the resource 'settings on an existing input connector', which clearly differentiates it from sibling tools like create_input, delete_input, and describe_inputs. It precisely identifies what the tool does.

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 provided about when to use this tool versus alternatives. It does not mention prerequisites, scenarios, or contrast with create_input/alter_output. The only weak implication is 'existing', which hints it is for modification rather than creation, but this is not explicit.

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 must disclose behavior, but it fails to mention the dry_run and confirm_write parameters that gate writes, nor does it warn about destructive potential.

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 single-sentence description is concise and front-loaded with the action and target, containing no filler.

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

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

For a mutation tool with no annotations and an open payload schema, the description is minimal and omits critical behavioral and parameter usage details, making it insufficient for reliable 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?

With 0% schema coverage, the description should compensate, but it only lists high-level alteration areas without explaining how payload, dry_run, and confirm_write should be used.

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 'Alter' with the resource 'integration table' and enumerates the modifiable aspects (fields, transform steps, retention policy), making its purpose clear and distinguishing it from create/delete 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?

It implies usage for modifying an existing table's configuration, but provides no explicit guidance on when to use this tool over alternatives like create_integration_table or test_integration_table_transform_steps.

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 full burden for behavioral disclosure. It only states 'Modify settings' without explaining side effects, reversibility, or the existence of safety mechanisms like dry_run and confirm_write. This is comparable to a mutation tool lacking permission or reversibility details.

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, grammatically clear sentence with no waste. It effectively communicates the core action, though it sacrifices depth for brevity, which is acceptable for conciseness but not for completeness.

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 includes safety-related parameters (dry_run, confirm_write) and an output schema, yet the description fails to mention these or how they shape behavior. It does not explain the write confirmation flow or how to use the tool safely, leaving significant gaps for a mutation 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 0%, and the description does not compensate. It mentions no parameters (dry_run, payload, confirm_write) and adds no meaning beyond the schema's bare field names. With three undocumented parameters, the agent cannot reliably construct a correct call.

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 'Modify settings on an existing output connector' uses a specific verb (Modify), identifies the resource (existing output connector), and clearly distinguishes from sibling tools like create_output, delete_output, and alter_input.

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 provided on when to use this tool versus alternatives. It does not mention creation or deletion as separate tools, nor does it state prerequisites or exclusions, leaving the agent to infer usage 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 transparency burden. The verb 'Summarize' strongly signals a read-only informational operation, and the zero-parameter schema reinforces that no state changes are involved. It does not explicitly state side-effect freedom or auth requirements, but for a no-param meta-summary tool this is adequately 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 a single, front-loaded sentence with no filler. It conveys the tool's purpose and distinctive value in a compact form.

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

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

Given the tool's simplicity (zero parameters, output schema provided, no complex behavior), the description fully covers what the agent needs to know. It succinctly explains both the subject matter (tools exposed) and the specific angle (write-safety model).

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 parameter schema is empty, so there are no parameter semantics to explain. The baseline of 4 applies since no parameters exist and the description does not need to compensate for undocumented 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 clearly identifies the tool's purpose: summarizing the exposed tools and their write-safety model. This is a specific verb-resource pairing that distinguishes it from sibling tools, which are individual data operations.

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

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

The description implies usage context: when an agent needs an overview of the MCP server's capabilities and safety classification. It does not explicitly mention alternatives or exclusions, but no competing summary tool exists among siblings, so the context is 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, the description carries full responsibility for disclosing behavior. It fails to mention that this is a write operation, the role of confirm_write or dry_run, potential side effects, or whether it overwrites existing packages. This lack of transparency leaves safety concerns unaddressed.

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 succinct sentence with no redundant words, effectively communicating the core action. It is well-structured and front-loaded.

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

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

Given the tool has 6 parameters and a write operation with safeguards (dry_run, confirm_write), the description is underspecified. It does not mention return behavior, prerequisites, or the workflow of cloning, making it insufficient for an agent to invoke without additional information.

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

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

Schema description coverage is 0%, so the description must compensate. While it clarifies code_name and new_code_name, it says nothing about dry_run, owner_name, confirm_write, or database_name, leaving their purpose and defaults unexplained.

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 a specific action ('clone') and resource ('code package') with a target ('under a new name'), which is distinct from sibling tools like register_code_package, revert_code_package, list_code_packages, and describe_code_packages.

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 such as register_code_package or revert_code_package. It does not mention prerequisites, suitable scenarios, or any exclusions. The usage context is left entirely to inference.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It reveals that the tool can create or update (implying mutation) and bind to an integration table, but it does not disclose side effects, idempotency, permission requirements, dry_run semantics, confirm_write behavior, or error conditions. The single sentence is insufficient for a write-oriented 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 a single, front-loaded sentence with no fluff or wasted words. It communicates the primary purpose efficiently. However, it is somewhat under-specified, though that is more a completeness issue than a conciseness issue, so a 4 is appropriate.

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

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

Given the tool's moderate complexity (3 parameters, output schema, no annotations), the description is too thin. It does not explain the payload structure, the meaning of dry_run/confirm_write, or any behavioral consequences. While an output schema exists, the input semantics remain entirely unexplained, making the tool difficult to invoke 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?

Input schema coverage is 0% and the description provides no explanation for the three parameters (dry_run, payload, confirm_write). Since the description must compensate for the missing parameter information but does not, the agent has no clues about what payload structure is expected or how dry_run and confirm_write affect execution.

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 ('Create or update') and the resource ('an MQTT topic') plus the binding outcome ('bind it to an integration table'). This differentiates it from sibling tools like delete_topic, list_topics, and describe_topics, which perform different operations on topics.

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 provided about when to use this tool versus alternatives. The description only states what the tool does, leaving the agent to infer that it is used for configuring topics. There are no explicit exclusions or mentions of sibling tools that might be more appropriate for read-only or deletion scenarios.

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 only states the action of creating, but it does not explain side effects, confirm_write behavior, dry_run implications, or any other practical consequences. This is a significant gap for a mutating 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 a single, concise sentence with no wasted words, efficiently conveying the core purpose. However, its brevity borders on under-specification, which is more of a completeness issue than a conciseness problem.

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

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

Given the tool has three parameters, no annotations, and an output schema (though its content is unknown), the description is too sparse to fully understand the tool's behavior, parameters, or expected outcomes. It is only minimally viable for a simple creation action.

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

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

Schema description coverage is 0% and the description does not mention any of the three parameters (dry_run, payload, confirm_write). It fails to compensate for the lack of schema documentation, leaving the agent without any semantic understanding of these parameters.

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

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

The description clearly states the tool creates a new input connector, with a specific verb 'create' and a defined resource 'input connector', and it adds context by mentioning it collects data from a device or software system. This distinguishes it from sibling tools like create_output or alter_input.

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 such as alter_input or create_output. Sibling tools exist for related operations, but no exclusions or preferred scenarios 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?

With no annotations provided, the description should carry the full burden of behavioral disclosure. It only states 'create an integration table' and does not mention side effects, permissions, idempotency, or the roles of dry_run and confirm_write parameters.

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 redundant wording. It is efficient, though it may be too terse to convey necessary details.

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

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

Despite having an output schema, the description remains incomplete for a create operation. It does not explain the parameters' semantics, preconditions, or expected behavior, making it insufficient for an agent to fully understand the tool's invocation and effects.

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

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

Schema description coverage is 0%, so the description must compensate. It vaguely references 'fields and transform steps' but does not clarify how these map to the payload parameter, nor does it explain dry_run or confirm_write. This adds minimal value beyond the raw schema.

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

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

The description clearly states the tool's purpose: creating an integration table, with optional fields and transform steps. This distinguishes it from sibling tools like alter, delete, and list operations on integration tables.

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 verb 'create' implies the tool is for creating new integration tables, but there is no explicit guidance on when to use it versus alternatives, nor any exclusion of use cases. The usage is implied but not articulated.

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 of behavioral disclosure. It only states the basic create action and outcome, but omits critical behavioral details such as the dry_run mode, confirm_write requirement, side effects, or whether creation is reversible. This is a significant gap for a mutation 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 a single, clear sentence with no wasted words. It is front-loaded with the action and resource, making it immediately understandable and appropriately concise.

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

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

The tool has three parameters and an output schema, but the description gives no context about the creation workflow, the role of dry_run/confirm_write, or what the payload should contain. The presence of an output schema means return values don't need explanation, but the operational process is left entirely unspecified, making the description incomplete for effective use.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters (dry_run, payload, confirm_write). It adds no meaning beyond the bare schema, failing to compensate for the lack of parameter-level documentation.

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 ('Create'), identifies the resource ('output connector'), and clarifies its purpose ('delivers collected data to an external service'). This clearly distinguishes it from sibling tools like create_input or create_integration_table.

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 intended usage is implied by the tool name and description: use it when you need to create a new output connector. However, it provides no explicit guidance on when to use it versus alternatives (e.g., alter_output) or any exclusions, so it falls short of clear contextual guidance.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. It only restates the delete action from the name, omitting side effects, reversibility, confirmation requirements, or the meaning of dry_run and confirm_write.

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 with no redundancy, making it concise and front-loaded. However, its brevity comes at the cost of missing critical operational details.

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

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

Given the tool has three parameters and no annotations, the description is under-specified. It does not explain the purpose of dry_run or confirm_write, nor does it address the deletion process, leaving the agent without sufficient context 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 0%, and the description provides no parameter information. The parameters dry_run, payload, and confirm_write are completely undocumented, leaving the agent without any semantic understanding.

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 'Delete' and clearly identifies the resource as 'input connector definition'. This distinguishes it from sibling tools like delete_output, delete_topic, and delete_integration_tables.

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 provided on when to use this tool versus alternatives like alter_input, or any prerequisites. The presence of dry_run and confirm_write parameters suggests a safety workflow, but the description fails to mention these or any usage 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?

With no annotations, the description must disclose behavioral traits. It states the tool deletes resources, which implies destructive action, but does not explain confirm_write, dry_run, or consequences such as reversibility. The presence of safety parameters is ignored, leaving the agent without awareness of safeguards.

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 very concise, consisting of a single clear sentence. It is front-loaded with the verb and resource, avoiding unnecessary words. However, it omits essential details, making it arguably too terse for a tool with multiple safety parameters.

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 highly incomplete for a tool with three parameters and no annotations. It does not explain safety mechanisms (dry_run, confirm_write), the format of payload, or the effect on dependencies. The presence of an output schema does not compensate for missing behavioral context.

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

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

Schema description coverage is 0%, and the description provides no information about the parameters. It does not explain how to specify which integration tables to delete, what payload should contain, or how dry_run and confirm_write affect behavior. This is a critical gap.

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 ('Delete'), the resource ('integration tables'), and scope ('one or more'). It is specific and distinguishes from sibling tools like create_integration_table or alter_integration_table. The purpose is unambiguous.

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

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

No guidance is provided on when to use this tool or when not to. It does not mention alternatives, prerequisites, or confirmation requirements. The description merely restates the function without contextualizing it relative to other integration table operations.

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 only says 'Delete' without mentioning the destructive and irreversible nature, the need for confirm_write or dry_run, or what happens to dependent resources. This is a serious gap for a deletion 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 a single sentence with no filler, but it is under-specified. It is not a tautology, yet it lacks necessary detail about the operation's parameters and safety behavior. It is concise but not optimally structured for an AI agent.

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

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

The tool has three parameters, an output schema, and no annotations, but the description explains none of this. It fails to cover the dry_run/confirm_write flow, what payload is required, or any side effects. For a delete operation, this is completely inadequate.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters (dry_run, payload, confirm_write). It fails to explain what payload contains, how dry_run works, or the role of confirm_write. The description adds no semantic value beyond the parameter names.

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

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

The description states a specific verb and resource: 'Delete an output connector definition.' It clearly identifies the tool's function and distinguishes it from related sibling tools like delete_input or delete_topic by specifying 'output connector.' The purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention when deletion is appropriate, prerequisites (e.g., needing to describe outputs first), or mention alternative tools such as alter_output for modification. There is no when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states 'Delete an MQTT topic' without mentioning the destructive nature, the need for confirmation (confirm_write), the availability of dry_run, or any side effects. The schema hints at these safety mechanisms, but the description does not elaborate.

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, which is concise in length, but it is under-specified for a tool with three parameters, an output schema, and destructive semantics. It omits essential information, so it is not appropriately sized for the tool's complexity.

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

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

The description provides only a minimal purpose statement and lacks any information about usage context, parameter semantics, behavioral details, or safety considerations. Although an output schema exists, the description itself is insufficient for an agent to select and correctly invoke this tool in a realistic workflow.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (dry_run, payload, confirm_write). An agent has no way to infer what these parameters mean or how to set them from the description alone.

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 (delete) and the resource (MQTT topic), which distinguishes it from sibling tools like list_topics, describe_topics, and configure_topic. It is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites, conditions, or contrasting scenarios with the many related sibling tools. For example, it doesn't say when to use delete_topic instead of configure_topic.

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 mentions that it describes one or more packages by name, but does not disclose read-only behavior, handling of invalid names, or any side effects. Minimal behavioral detail is given.

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

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

The description is a single sentence with no wasted words, front-loading the verb and object. 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?

Despite having an output schema, the description lacks essential context for a tool with 4 parameters and no annotations. It does not explain the optional parameters, usage scenarios, or behavior with multiple inputs, making it minimally viable at best.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints at 'code_names' via 'by name'. Optional parameters like owner_name, code_format, and database_name are left completely unexplained.

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 'Describe' and resource 'code packages' with scope 'by name', clearly identifying the tool's function. It distinguishes from list_code_packages by implying specific named lookups, though it does not explicitly name alternatives.

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 like list_code_packages. The description simply states the action without any contextual cues 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 burden of behavioral disclosure. The brief wording implies a read-only operation but does not explicitly state it, nor does it mention any side effects, permissions, error conditions, or details about the response format. This lack of transparency could mislead an agent about expectations.

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, clear sentence with no redundant words. It front-loads the primary action and effectively conveys the core purpose within a compact 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 simple tool with an output schema, the description is minimal but lacks contextual completeness. It does not explain how this tool fits among siblings or when to choose it over describe_inputs/describe_outputs. While the output schema can provide return details, the absence of usage guidance and parameter clarification leaves the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at parameter meanings by mentioning 'input or output' (relevant to 'direction') and 'for a service' (relevant to 'service_name'). However, it does not explicitly specify allowed values for 'direction' or clarify that 'service_name' is a configured service identifier. The default value in the schema helps, but the description adds only partial semantic value.

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

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

The description clearly states the tool's function: to describe the expected input or output connector payload schema for a service. It uses a specific verb ('Describe'), a resource ('connector payload schema'), and a scope ('for a service'). However, it does not explicitly distinguish this from sibling tools like describe_inputs/describe_outputs, though the term 'payload schema' implies a distinct focus.

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. It does not mention prerequisites, exclusions, or scenarios where another sibling tool would be more appropriate. This is a significant gap given the number of similar describe/list tools available.

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 must disclose behavior itself. It adds that payload.inputNames is required and that the tool expects names from list_inputs, which is helpful. However, it does not explicitly state that the operation is read-only, what happens for invalid names, or any error conditions, leaving notable gaps in transparency.

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, directly front-loaded with the action and resource, and every word adds value. It avoids repetition and clearly conveys the essential information without any fluff.

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

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

Given that an output schema exists, the description does not need to explain return values. The tool is simple (one parameter), and the description covers the critical input requirement and the discovery step. The only notable gap is a minor inconsistency with the schema's nullable payload default, but the description itself is sufficiently complete for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It clearly identifies the required key 'inputNames' within the payload and explains its purpose, which is essential. It could go further by specifying the expected type (e.g., array) or format, but the provided guidance adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool's function: describing one or more input connectors by name. It uses a specific verb ('Describe') and resource ('input connectors'), and distinguishes this from sibling tools like list_inputs by indicating names come from a prior listing.

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

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

The description gives explicit usage guidance: 'payload.inputNames is required' and instructs users to 'call list_inputs first to discover names'. This is a clear prerequisite that aids in correct invocation, though it does not mention when not to use the tool or alternatives beyond the implied listing step.

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 must carry the burden of disclosing behavior. It mentions 'describe' (implying read-only) and includes fields and transform steps, but it does not explicitly state whether it is a read-only operation, what authentication or permissions are needed, or what the response format will be. The output schema exists but the description does not reference it.

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

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

The description is extremely concise: one short sentence captures the essential purpose and scope. It is front-loaded and contains no unnecessary words, achieving maximum clarity in minimal space.

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

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

The description is far too skeletal for a tool with no annotations and an opaque parameter. It does not explain what 'payload' means, how to specify which tables to describe, or what the output schema contains. Given the availability of sibling tools for listing and altering tables, more context is needed to position this tool correctly.

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

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

The input schema has one generic parameter 'payload' with no description, and the schema description coverage is 0%. The tool description does not mention the payload at all, leaving its purpose and expected content entirely unexplained. This is a significant gap for a parameter-driven tool.

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: 'Describe one or more integration tables, including fields and transform steps.' It uses a specific verb ('describe') and identifies the resource and scope. However, it does not explicitly distinguish itself from sibling tools like 'list_integration_tables'.

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 guidance on when to use this tool versus alternatives. There is no mention of prerequisites, use cases, or exclusions. Sibling tools like 'list_integration_tables' or 'test_integration_table_transform_steps' exist, but the description does not indicate how this tool relates to them.

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 only says 'describe', which suggests read-only behavior, but does not disclose what happens for unknown names, whether multiple names are accepted at once, or how the payload should be formed. The optional/null payload creates ambiguity about whether no payload describes all outputs.

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 concise sentence with no redundant words, 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 one optional payload and an output schema, the description leaves critical input semantics ambiguous. It doesn't explain what the payload should contain, how to identify outputs, or the effect of omitting it. The output schema covers returns, but not invocation details.

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

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

The input schema has a single generic payload object with no documentation (0% coverage). The description adds only that describing happens 'by name', but doesn't specify the payload structure (e.g., an array of strings, an object with a names field).

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 (describe) and target (output connectors), with a specific constraint (by name), distinguishing it from list_outputs which presumably enumerates all outputs.

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 explicit guidance on when to use this tool versus alternatives like list_outputs or describe_connector_schema. The phrase 'by name' implies the caller must know the connector names, but no exclusions or alternative tool references 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, the description must carry the burden of behavioral disclosure. The word 'Describe' implies a read-only operation, and 'by name' indicates a lookup-by-name behavior, which adds some value. However, it does not disclose potential errors for missing tables, the effect of having both optional parameters set, or any permission or performance characteristics. It partially misses the opportunity to clarify behavior beyond the obvious.

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

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

The description is a single sentence, concise, and front-loaded with the action verb. It contains no unnecessary words or redundancy, earning a high score 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?

Given the tool has two ambiguous optional parameters and numerous sibling tools, the description is far too sparse to provide complete guidance. It does not explain when to choose this tool, how to handle the parameters, or what 'metadata' exactly includes. While an output schema exists and could cover return values, the overall context is insufficient for correct tool selection and 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 0%, so the description should clarify the parameters. It says 'by name' but does not indicate which of the two parameters (table or table_name) should be used, nor the relationship between them. The property names are somewhat self-explanatory, but the description fails to add meaningful disambiguation, leaving uncertainty for the agent.

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 'Describe' with a clear resource 'a table' and specifies the scope 'columns and metadata'. This distinguishes it from siblings like list_table_columns and list_table_indexes, which focus on individual structures. The phrase 'by name' further clarifies that the input is a table 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?

The description provides no guidance on when to use this tool versus alternatives like list_table_columns or describe_integration_tables. It lacks any mention of when to prefer this tool, when not to, or how it relates to sibling tools in a workflow. The only implication is that it is used for table schema lookup, but no explicit context or exclusions are given.

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

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

There are no annotations, so the description carries the full burden of describing behavior. 'Describe' suggests a read-only operation, but the description doesn't explicitly state whether it returns details, whether multiple topics are handled, or any side effects. It is too minimal to inform the agent about the tool's operational traits.

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, well-structured sentence with no redundant words. It is front-loaded with the key information and earns its place without 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?

The tool is simple but the description omits essential details about the input format, even though an output schema exists. The generic 'payload' parameter is unexplained, making the tool under-specified for reliable invocation. The description does not adequately compensate for the lack of schema documentation.

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

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

The input schema has a single 'payload' parameter with anyOf object/null and no description, and schema coverage is 0%. The description says 'by name' but fails to explain how names should be provided in the payload. This leaves a critical gap in understanding how to correctly invoke the tool.

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 ('Describe') and clearly identifies the resource ('MQTT topics') and the means of selection ('by name'). This distinguishes it from sibling tools like list_topics, which list topics, and configure_topic/delete_topic, which modify them.

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

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

The description implies a use case (get details on one or more named topics) but provides no explicit guidance on when to choose this over list_topics or other describe tools. No alternatives or exclusions are mentioned, leaving the agent to infer the appropriate 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?

With no annotations, the description carries the full burden. It states what is returned but does not explicitly mention side effects or safety profile. As a 'getter' it is safe to assume read-only, but that is not disclosed; this is adequate but not rich behavioral 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 sentence that is front-loaded with the verb and resource, followed by a colon and a list of specific contents. Every word earns its place with no filler or repetition.

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

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

Given the tool has no parameters and an output schema exists, the description does not need to explain return values. It fully covers the tool's scope by describing exactly what the contract contains, making it complete for a simple metadata getter.

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 per rubric. The description adds no parameter information because none is needed; the empty schema is already self-explanatory.

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

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

The description uses a specific verb 'Return' with a clear resource: 'this server's tool usage contract.' It explicitly lists the contract's contents (argument aliases, canonical arg names, payload examples), making it distinctly different from sibling tools that manage tables, inputs, or services.

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 usage as a reference for understanding tool argument conventions, but it does not explicitly state when to use it versus alternatives or provide any exclusions. There is no guidance on scenarios like before using other tools, so it only meets the 'implied usage' level.

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 merely states the action 'List' without revealing read-only nature, filtering behavior, default limits, or any side effects. The description adds no context beyond the tool name 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?

The description is a single sentence, which is concise, but it is under-specified and borders on tautology. It avoids bloat but sacrifices necessary information, making it minimally acceptable rather than well-structured.

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

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

Despite having six optional parameters and an output schema, the description is severely incomplete. It does not explain what a code package is, how filtering works, or what the output represents, leaving the agent to guess or rely on schema names 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 0%, and the description provides no explanation of parameters like name_like, max_records, or status_filter. Parameter names offer some hints, but the description fails to define formats, allowed values, or how filters interact, leaving significant ambiguity.

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 'List registered code packages' clearly states a specific verb and resource, making the tool's purpose unambiguous. It distinguishes from siblings by using 'list' as opposed to 'describe' or 'register', though it does not explicitly call out that distinction.

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 offers no guidance on when to use this tool versus alternatives. There is no mention of use cases, prerequisites, or scenarios where this tool is preferred over sibling tools like describe_code_packages or other list tools.

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

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

No annotations are present, so the description must carry the behavioral burden. The verb 'list' and the phrase 'names of previously created' imply a read-only operation and indicate the return content, but it does not disclose potential effects of the payload parameter or any edge cases. It is minimally 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 a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's purpose and scope.

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 listing operation, the description is adequate and benefits from having an output schema. However, the complete lack of payload semantics and absence of any pointer to describe_inputs for details leaves the description minimally viable but not fully self-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?

The schema defines a single 'payload' parameter with 0% description coverage, and the tool description does not mention it at all. The agent has no guidance on whether payload is needed for filtering or what format it should take, making this a significant gap.

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 (input connectors), and the scope (names of previously created). This distinguishes it from sibling tools like describe_inputs and list_outputs.

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

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

The description provides clear context: it lists existing input connector names. It does not explicitly name alternative tools for similar tasks, but the use case is evident. A 4 is appropriate because it lacks explicit when-not-to-use guidance.

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

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

With no annotations provided, the description is responsible for disclosing behavior. It only says 'lists integration tables' and gives no information about output format, pagination, filtering, or potential side effects. This is minimal disclosure for a list 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 a single sentence with no wasted words, which is concise. However, it is under-specified, lacking essential details about the payload and the nature of integration tables, making it minimally useful.

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

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

The tool has a generic optional payload parameter, no annotations, and an output schema that is not referenced. The description does not explain what 'integration tables' are, what the payload accepts, or what the response contains. This is inadequate for a tool with this level of ambiguity.

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 one parameter 'payload' with 0% description coverage, and the description does not explain what the payload should contain or how it affects the listing. The tool description must compensate for the lack of schema documentation but fails to do so.

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) and the resource (integration tables) within a database. It is specific enough to indicate the tool's core function, but it does not distinguish itself from siblings like list_tables or describe_integration_tables, which could cause confusion.

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 such as list_tables or describe_integration_tables. The description only states what it does, without providing context, 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It indicates a read-only listing operation but does not clarify the role of the optional payload parameter, potential filtering, pagination, or error behavior. The description is too sparse to adequately inform the agent of the tool's behavior beyond the obvious 'list' semantics.

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 directly states the tool's purpose without unnecessary words. It is appropriately concise for a simple listing operation.

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, but the description is incomplete given the presence of an optional payload parameter and context from sibling tools. It does not explain the payload's role, nor does it position the tool relative to describe_outputs or other output-related tools. The output schema may describe return values, but the input side remains ambiguous, making the overall guidance insufficient 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?

The input schema has one optional payload parameter with no description (schema coverage 0%). The description also does not mention the payload parameter, its purpose, or how to use it. The description fails to compensate for the lack of schema documentation, leaving the agent with no understanding of the parameter's meaning.

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

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

The description clearly states the tool lists names of previously created output connectors, using a specific verb and resource. It distinguishes from siblings like describe_outputs (which would provide details) and list_inputs (different resource type).

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 provided on when to use this tool versus alternatives. It does not mention that describe_outputs is better for detailed information or that list_inputs covers inputs. The description only states what the tool does, leaving the agent to infer usage context from sibling names.

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 disclosing behavior. It does mention the runtime state values, which adds useful context. However, it does not explicitly state that the tool is read-only or has no side effects, though 'List' implies this. The description is adequate for a simple list operation 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?

The description is a single, front-loaded sentence with no filler. It clearly communicates the main function and the specific state filter in an efficient manner.

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 and has an output schema, so return values are likely covered there. However, the description omits any meaning for the payload parameter and provides no usage guidance relative to sibling tools. These gaps make it minimally complete but not comprehensive.

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 single optional parameter 'payload' is not mentioned in the description, and the schema provides no description for it (coverage 0%). This leaves the parameter's purpose entirely unexplained, offering no guidance on what values to pass or how it affects the listing.

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 lists FairCom services and includes their runtime state (enabled/running/disabled). It uses a specific verb (List) and resource (FairCom services), and the added state detail distinguishes it from sibling list tools like list_table_columns or list_inputs.

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 a read-only listing operation but does not explicitly mention when to use this tool versus alternatives. It offers no exclusion criteria or reference to sibling tools like manage_service for actions on services. The usage context is clear from the verb and resource, but not explicit.

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 for behavioral disclosure. It only restates the basic operation and does not disclose any behavioral traits such as read-only status, required permissions, pagination, or edge cases.

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 clear sentence with no wasted words. It is efficiently structured, though it could have added a bit more detail without becoming verbose.

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

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

Given the tool has two ambiguous optional parameters and no parameter documentation, the description is too minimal. It does not clarify which parameter to use or what 'table' vs 'table_name' refers to, making it insufficient for reliable tool 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 0%, and the description provides no explanation of the parameters 'table' and 'table_name'. Both are optional with default null, leaving the agent confused about how to specify the table or what distinguishes the two parameters.

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

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

The description clearly states the tool lists columns on a table, using the specific verb 'list' and resource 'columns defined on a table'. It also notes that integration tables are included, which helps distinguish it from related tools like list_table_indexes.

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 usage when you need column definitions, but it doesn't explicitly state when to prefer this over list_table_indexes or describe_table, nor does it mention alternatives or exclusions. The phrase 'including integration tables' offers some context but no clear guidance.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states that indexes are listed, with no details about output format, ordering, error behavior, or permissions. For a read operation, this is minimally transparent but falls short of what the rubric expects.

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 clear sentence with no waste, and the main action is front-loaded. However, it is slightly under-specified given the ambiguous parameters, but conciseness itself is strong.

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?

Although an output schema exists, the description leaves significant gaps: the two parameters are unexplained, no usage context is given, and no alternative tools are mentioned. For a tool with low complexity, the description is still not complete enough to use correctly without further investigation.

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

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

Schema coverage is 0%, yet the description does not explain the two parameters ('table' and 'table_name') at all. Both are optional with default null, but their purpose and relationship are entirely ambiguous, and the description 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?

The description clearly states the tool's purpose with a specific verb ('List') and resource ('indexes defined on a table'). It distinguishes from siblings like list_table_columns by specifying indexes rather than columns.

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 exclusions, and no mention of prerequisites. The description is a single sentence with no contextual usage advice.

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. The verb 'list' implies read-only, but the description does not confirm this, nor does it disclose pagination, ordering, permissions, or scope (e.g., all tables vs. within a specific schema). This leaves key behavioral traits unclear.

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

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

The description is a single sentence that is front-loaded and free of any filler. It is appropriately concise for the simple action of listing tables, although it could have included parameter details without losing its efficiency.

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

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

The tool has three optional parameters, no annotations, and is part of a large sibling group with many table-related tools. The description is too minimal to provide complete context for correct invocation, leaving ambiguity about parameter meanings and when to choose this tool over others. The output schema provides return type info but does not compensate for the lack of parameter and usage guidance.

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 defines three optional parameters with zero coverage in the description. The phrase 'name pattern' is ambiguous and does not distinguish between name_like and table_like, and the database parameter is completely unexplained. The description adds no meaningful information about parameter purposes or relationships.

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: 'List database tables'. It is specific about the resource (database tables) and the verb (list), distinguishing it from sibling tools like list_table_columns and list_table_indexes which focus on other database objects.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or typical scenarios. The sibling tools are not referenced, leaving the agent to infer usage 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 must convey behavioral traits. The verb 'list' implies a read-only operation, and 'the server is tracking' adds scoping context. However, it does not mention pagination, ordering, or whether system topics are included, and it does not explicitly state that no modifications occur. The description 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?

The description is a single, front-loaded sentence with no fluff. It states the action, resource, and scope in eleven words, earning 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?

Given the tool's simplicity and the presence of an output schema, the description sufficiently covers the core purpose. It could be more complete by clarifying what 'tracking' means or whether the result includes system topics, but for a list-names utility, the description is reasonably 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?

The input schema has one parameter 'payload' with no description (schema coverage 0%), and the description does not mention it. Since the parameter is optional and defaults to null, it may be a generic placeholder, but the agent receives no guidance on what to pass or why. The description fails to compensate for the lack of schema documentation.

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' plus the resource 'names of MQTT topics' and scoping 'the server is tracking.' This clearly distinguishes it from sibling tools like describe_topics (which would provide details) and configure_topic/delete_topic (which mutate).

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 clear: use this tool to get topic names. However, it does not explicitly state when not to use it or mention alternatives (e.g., 'for details, use describe_topics'). The sibling tool names provide implicit guidance, but the description itself offers no 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 must carry the full burden of behavioral disclosure. It only lists the actions without explaining side effects, required confirmations, permissions, or the impact of a dry run. The mutating nature is implicit but not elaborated.

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, succinct sentence that immediately lists all supported actions. It is front-loaded, contains no filler, and every word contributes to the 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?

The tool has multiple parameters and an output schema, but the description lacks the necessary detail to invoke it correctly. It does not explain how to select an action (likely via payload) or the meaning of dry_run and confirm_write, leaving significant gaps for a mutating service management 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?

With zero schema description coverage, the description was expected to compensate by explaining parameters like payload, dry_run, and confirm_write, but it makes no mention of them. The agent receives no guidance on how to specify which action to perform or what values these parameters accept.

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 specifies the tool's function: pausing, resuming, restarting, shutting down, or starting up a FairCom service. It uses a specific verb+resource structure and distinguishes itself from sibling tools like list_services by describing actions rather than observation.

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 usage for service lifecycle management by listing the available actions, but it does not explicitly state when to use this tool versus alternatives or provide context about prerequisites or exclusions. There is no mention of when not to use it or how it complements listing tools.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It clearly indicates a read-like operation ('Return') and specifies the content, but does not disclose any caveats such as access restrictions, retention period, pagination behavior, or whether the operation is safe/idempotent. For a read-only audit tool, this is adequate but leaves room for more 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?

A single, concise sentence that is front-loaded with the action and object. No filler, every word adds meaning, and it is immediately understandable.

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 with no parameters, and an output schema exists, so the description does not need to explain return values. The description covers the core purpose and scope, but the term 'recent' is underspecified regarding the time window. Overall, it is sufficient for an agent to select and invoke the tool correctly, though additional detail on the time window would improve completeness.

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 input schema is an empty object, so the baseline is 4. The description does not add parameter-specific details because there are none to describe. It does not overcomplicate or introduce ambiguity.

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 ('Return') and resource ('recent audit log entries') with a clear scope ('for write operations performed through this server'). It clearly distinguishes from sibling observability tools like observability_metrics and observability_health, which focus on metrics and health status, whereas this tool returns audit log entries.

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 appropriate usage by specifying the subject (audit log entries) and the subset (write operations), which helps the agent decide when to use this tool versus the observability_metrics or observability_health siblings. However, it does not explicitly mention when not to use it or name alternative tools.

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

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

With no annotations, the description carries the full burden. It only says 'returns health status' without disclosing whether the operation is read-only, what error conditions exist, or what the health response structure is. For a simple health check, these details are minimal but still absent.

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 or wasted words. It gets straight to the point and is appropriately brief.

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

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

Given the tool's simplicity (no parameters) and the existence of an output schema (which presumably explains the return value), the one-line description is nearly complete. However, it could mention the intended use case or differentiate from runtime_status, but this is not critical for a health check.

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

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

The tool has zero parameters, so there is nothing to document. The schema coverage is trivially 100%, and the description correctly avoids adding redundant parameter information.

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

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

The description clearly states the tool returns the MCP server's health status, with a specific verb and resource. It is distinguishable from sibling tools like observability_metrics and observability_audit, but the overlap with runtime_status is not addressed.

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 provided on when to use this tool versus alternatives like runtime_status. The description implies a health check, but there are no explicit exclusions or alternative references.

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 not mention whether the operation is read-only, what specific metrics are included, or any side effects. The phrase 'operational metrics' is vague and lacks detail about the tool's behavior beyond its 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, grammatically correct sentence that conveys the core purpose without unnecessary words. It is appropriately sized and front-loaded, achieving maximum efficiency.

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 that this is a simple no-parameter tool and an output schema exists, the description does not need to explain return values. However, it lacks context on what 'operational metrics' encompasses, which could be clarified to help the agent decide if this is the right tool among similar observability functions. Still, the description is adequate for a low-complexity tool.

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

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

The tool has zero parameters, and the schema is empty, so there is nothing to explain. The description does not add parameter-specific information, but none is needed. The baseline of 4 applies for tools with no parameters.

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

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

The description clearly states the tool returns operational metrics for the MCP server, using a specific verb and resource. However, it does not explicitly distinguish itself from sibling tools like observability_health or observability_audit, which likely serve related purposes.

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 such as observability_audit or observability_health. It merely states what the tool does, leaving the agent to infer usage context without explicit direction.

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

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

With no annotations, the description should disclose side effects but only says 'Create or update.' It fails to mention whether updates overwrite existing code packages, how dry_run or confirm_write affect behavior, or any permission/ownership requirements. This is a significant transparency gap for a mutation 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 single-sentence description is concise and front-loaded, but it is under-specified. It earns its place by stating the core purpose but omits critical operational details that could be added without excessive length. This is closer to under-specification than model conciseness.

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

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

Given the tool has 13 parameters, a write action, and an output schema, the description is far from complete. It does not explain the create/update distinction, required parameters, or the role of safety flags like dry_run and confirm_write. The output schema reduces the need to describe return values, but the input complexity demands more context.

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

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

Schema description coverage is 0%, so the description must compensate for the 13 parameters. It only adds the fact that the code is JavaScript, but does not explain code_name, code, metadata, input_fields, output_field_definitions, code_status, or any other parameter. The provided example gives a use case but no parameter-level meaning.

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

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

The description clearly states the action (create or update) and resource (JavaScript code package) with a concrete example ('such as an integration table transform'). It implies a write/upsert behavior, distinguishing it from read-only siblings like list_code_packages and describe_code_packages, though it does not explicitly name alternative tools.

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

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

No explicit guidance on when to use this tool versus siblings such as clone_code_package or revert_code_package. The description does not mention prerequisites, create-vs-update decision factors, or exclusion scenarios, leaving usage context ambiguous.

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 not explain whether the revert is destructive, requires confirmation, or is reversible. The presence of dry_run and confirm_write parameters is not mentioned in the description, leaving critical behavioral aspects undisclosed.

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

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

The description is a single sentence that communicates the core purpose efficiently. It is appropriately concise 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?

Despite having an output schema and 6 parameters, the description is incomplete for a mutation tool. It fails to cover essential behavioral context, parameter semantics, and safety considerations, making it insufficient for an agent to invoke correctly without additional information.

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

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

Schema description coverage is 0%, and the description adds almost no parameter semantics. It gives general context for 'code_name' and 'version' but completely ignores dry_run, confirm_write, owner_name, and database_name, offering no help in understanding their purpose or usage.

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 'revert' with a clear resource 'code package' and target 'prior version'. This clearly distinguishes it from sibling tools like register_code_package, clone_code_package, and describe_code_packages.

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, nor does it mention prerequisites, when to avoid, or selection criteria. It merely states the action without contextual usage direction.

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

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

With no annotations, the description communicates the tool's non-destructive nature via 'Report', and it adds context by scoping to the server's own runtime and configuration. However, it doesn't elaborate on potential failure modes or access requirements, though this is acceptable for a status endpoint.

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

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

The description is a single sentence, front-loaded, with no wasted words. It perfectly achieves conciseness while conveying the essential 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?

For a zero-parameter status tool with an output schema, this description is complete. It provides enough information for an agent to select the tool for server status checks without needing further explanation.

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 description does not need to explain parameter semantics. The schema already documents everything (100% coverage), and the baseline for zero params is 4.

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 identifies the tool's function with the verb 'Report' and specifies the resource as 'this MCP server's own runtime and configuration status', which distinguishes it from sibling tools that focus on external resources or observability metrics.

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 use when an agent needs to check the server's runtime or configuration state. While it doesn't explicitly exclude alternatives, the clarity of 'own...status' provides sufficient context for when to invoke. No exclusions are needed for such a simple introspection tool.

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 must carry the full behavioral burden. It correctly states that the tool performs writes, but it does not disclose the mutative side effects, the need for confirm_write, the behavior of dry_run, or what the response contains. For a write tool, this leaves important behavioral ambiguities.

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. It efficiently conveys the core purpose, though its brevity comes at the cost of completeness.

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 six parameters, no annotations, and no schema descriptions, one sentence is far from complete. It lacks guidance on parameter selection, safeguards like dry_run and confirm_write, and the boundary with sql_query. It is not redundant with the schema because the schema has no descriptions.

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

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

Schema description coverage is 0%, and the description adds almost no parameter-level meaning. It only indicates the SQL should be an insert/update/delete; it does not clarify that sql/query/statement are likely alternative parameters, nor explain the roles of params, dry_run, or confirm_write. This is insufficient given six undocumented parameters.

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

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

The description clearly states the exact operation ('Execute a write SQL statement'), enumerates the statement types (insert/update/delete), and names the target ('FairCom'). This distinguishes it from sibling read tools like sql_query and sql_query_page.

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 'write SQL statement' wording establishes that the tool is for mutations, which implies sql_query/sql_query_page are for reads, but the description does not explicitly state when to use this tool vs alternatives or mention any exclusions or prerequisites.

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

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

The description discloses the key behavioral trait of being read-only, which is important for safety. However, no annotations exist, and the description does not mention behavior around parameter precedence, query execution limits, or error handling, leaving gaps beyond the read-only hint.

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 wasted words. It immediately communicates the tool's core 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?

Given there are four parameters, no annotations, and a complex set of sibling query-related tools, the description is too minimal. The read-only note and database mention help, but the lack of parameter guidance and tool-comparison context makes the overall definition incomplete for reliable use.

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

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

Schema description coverage is 0% and the description does not explain any of the four parameters (sql, query, params, statement). The description adds no meaning beyond what the schema lists, leaving the agent uncertain whether sql/query/statement are aliases or how params should be used.

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 ('Run') and resource ('FairCom database') while explicitly noting the read-only nature, which distinguishes it from the sibling tool sql_execute. This is a clear, specific purpose statement.

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 provided on when to use this tool versus alternatives like sql_execute or sql_query_page. The description only states what it does, not the context that differentiates it from siblings.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It states 'read-only,' which is a key safety property, and notes pagination, but it does not explain continuation tokens, ordering, or the relationship between multiple SQL parameters. This is a moderate level of transparency for a complex 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 a single, concise sentence that front-loads the core purpose. It contains no redundant or extraneous content. However, the extreme brevity leaves out useful details, preventing a perfect score.

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

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

Given the high complexity (8 params, no annotations, no schema descriptions), the one-sentence description is inadequate. It does not explain how pagination is controlled, how the query parameter variants relate, or how the tool handles large result sets. The presence of an output schema helps but does not compensate for the missing operational context.

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

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

Schema description coverage is 0%, and the description provides no parameter-level detail. With 8 parameters including sql, statement, query, page, continuation_token, params, order_by, and page_size, the description fails to clarify which are mutually exclusive, how pagination works, or what values are expected. This is a significant gap.

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: 'Run a read-only SQL query and return one page of results at a time.' It specifies the verb, the resource (SQL query), and a distinguishing feature (pagination). This also differentiates it from sibling tools like sql_query and sql_execute.

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 usage for read-only, paginated querying, but it does not explicitly state when to choose this tool over alternatives such as sql_query or sql_execute. There is no mention of when not to use it or any exclusion criteria. The usage context is reasonable but relies on inference.

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

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

With no annotations, the description carries the burden of disclosing behavior. It suggests the tool is non-destructive ('before applying them for real'), but it does not disclose the effects of parameters like 'dry_run' or 'confirm_write', nor does it mention permissions, rate limits, or potential side effects. This is a significant gap for a tool that may have write behavior via 'confirm_write'.

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, well-structured sentence that immediately states the purpose. No filler or redundant information. It is appropriately sized for a tool aimed at testing, though it could be slightly richer in 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?

Given the tool has three parameters, no annotations, and an output schema, the description should provide more context about the testing flow, what happens with different parameter combinations, and the expected behavior. The current description is too minimal to fully guide an agent in using this tool effectively, especially regarding the rollout aspect and the meaning of 'real' application.

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

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

Schema description coverage is 0% and the description adds no meaningful information about the three parameters ('dry_run', 'payload', 'confirm_write'). It only vaguely references 'records' without explaining how they map to the payload parameter. The description fails to compensate for the schema's lack of parameter descriptions.

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 a specific action ('Test') on a specific resource ('an integration table's transform steps') with a specific scope ('against records before applying them for real'). It distinguishes this from sibling tools by focusing on the testing/validation aspect rather than listing, creating, or deleting tables.

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

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

It provides clear context for when to use the tool: to test transform steps against records before applying them for real. This implies a dry-run validation purpose. However, it does not explicitly mention when not to use it or name alternative tools, so it falls just short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that validation is performed 'locally without writing to FairCom,' which is a crucial side-effect disclosure. However, it stops short of detailing what validation entails (e.g., error reporting, prerequisites), so it is 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 a single, well-structured sentence that leads with the verb and resource, then adds the essential qualifier. Every word earns its place, and there is no redundant or extraneous 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 tool has a simple interface with optional parameters and an output schema, so the description does not need to explain return values. However, the lack of parameter documentation and missing usage guidance leaves gaps in the overall understanding. The description conveys the core purpose but is not fully complete for an agent to invoke the tool correctly without additional schema inspection.

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

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

The input schema has 0% description coverage, and the description only partially compensates by mentioning 'one or more connector payloads,' which maps to the 'payload' and 'payloads' parameters. The 'action' parameter is entirely unexplained; the schema provides a default but no semantic guidance. The description fails to clarify how to use the tool correctly for different validation scenarios.

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 ('Validate') and resource ('connector payloads') and adds a key qualifier ('locally without writing to FairCom') that clearly distinguishes it from sibling CRUD tools. It immediately conveys the tool's unique scope and non-destructive nature.

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 usage as a pre-check before writing to FairCom, but does not explicitly state when to use this tool versus alternatives or name specific sibling tools. The context is present but vague, leaving the agent to infer when it should be selected over create/alter operations.

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