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

Annotations already declare destructiveHint=true and idempotentHint=true, so the agent knows this is a destructive but idempotent operation. The description adds no behavioral context beyond what annotations provide (no mention of permissions needed, confirmation requirements, or what happens to associated data). No contradiction with annotations exists.

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 - a single sentence that directly states the tool's purpose with zero wasted words. It's appropriately front-loaded with the core action. For a simple deletion tool, this level of brevity is efficient.

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

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

For a destructive operation with 0% schema coverage and no output schema, the description is inadequate. It doesn't explain what a 'Business Object' is, what deletion entails, what the 'name' parameter should contain, or what happens after deletion. The annotations help but don't compensate for these gaps in the description itself.

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 carries full burden for parameter documentation. It mentions no parameters at all, leaving the single 'name' parameter completely undocumented. The description fails to explain what 'name' represents or its format, providing no value 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 verb ('Delete') and resource ('Business Object'), making the purpose immediately understandable. It distinguishes from siblings like 'businessobject-update' by specifying deletion rather than modification. However, it doesn't specify what constitutes a 'Business Object' in this context, which slightly limits specificity.

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. With siblings like 'businessobject-update' and 'businessobject-function-delete', there's no indication of when deletion is appropriate versus updating or deleting functions. No prerequisites or exclusions 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?

Annotations provide critical behavioral hints (destructiveHint: true, idempotentHint: true, readOnlyHint: false), but the description adds value by specifying that it deletes 'an existing' function, implying it requires pre-existence. It doesn't contradict annotations, and while it could mention more (e.g., permissions, side effects), it offers useful context beyond the structured data.

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 zero waste—it directly states the tool's purpose without unnecessary elaboration. Every word earns its place, making it highly efficient and easy to parse.

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

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

For a destructive tool with 2 undocumented parameters, no output schema, and no sibling differentiation, the description is inadequate. It lacks details on parameter meanings, usage context, or expected outcomes, failing to compensate for the schema and annotation gaps.

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

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

With 0% schema description coverage for 2 parameters, the description fails to add any semantic meaning beyond what the bare schema provides. It doesn't explain what 'businessObjectName' or 'functionName' represent, their formats, or examples, leaving parameters largely undocumented.

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 target resource ('an existing Business Object Function'), providing specific verb+resource pairing. However, it doesn't explicitly distinguish this tool from sibling tools like 'businessobject-delete' or 'businessobject-function-update', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'businessobject-function-update' or 'businessobject-delete'. It lacks context about prerequisites, appropriate scenarios, or exclusions, offering only a basic statement of purpose.

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

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

The description adds significant behavioral context beyond what annotations provide. While annotations indicate read-only, non-destructive, and idempotent operations, the description adds crucial details about error handling (404 for wrong names, 400/500 for parameter issues), parameter usage rules (name vs. alias), and data type requirements. This provides valuable operational context that annotations alone don't convey.

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

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

The description is well-structured with clear sections (Common Base Data Type IDs, Parameter Usage, Error Handling) and front-loads the core purpose. While comprehensive, some information like the full list of data type IDs could be considered slightly verbose, but each section earns its place by providing essential operational guidance.

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 3-parameter tool with no output schema and only 33% schema description coverage, the description provides substantial contextual information. It covers purpose, usage, parameters, data types, and error handling comprehensively. The main gap is the lack of information about return values or output format, which would be helpful given the absence of an output schema.

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

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

With only 33% schema description coverage, the description compensates substantially by explaining parameter usage in detail. It clarifies the relationship between 'name' and 'alias' parameters, provides data type IDs for common types, and explains value matching requirements. This adds meaningful semantic understanding beyond the basic schema structure, fully addressing the coverage 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 specific action ('Execute a business object function with provided input parameters for testing purposes') and distinguishes it from siblings by focusing on testing rather than creation, deletion, or updating. It explicitly mentions this is for testing with real data, which differentiates it from other business object tools that perform modifications.

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 about when to use this tool ('for testing purposes' and 'test your functions with real data'), but doesn't explicitly state when NOT to use it or name specific alternatives. It implies usage for testing functions rather than production execution, but lacks explicit exclusions or comparisons to sibling tools like businessobject-function-update.

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

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

Annotations provide readOnlyHint=false and destructiveHint=false, indicating mutation capability without destruction. The description adds valuable behavioral context beyond annotations: it explains code execution patterns (early returns, automatic postfixing), logging behavior (Simplifier.Log vs console.log differences), dependency requirements, and security/performance considerations. No contradiction with annotations exists.

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 excessively long (over 1000 words) and poorly structured. It mixes tool-specific instructions with general development guides, burying critical information. While some content is valuable, much could be trimmed or moved to external documentation. The front-loaded section is useful but followed by extensive tangential material.

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 complexity (8 parameters, mutation capability, no output schema) and low schema coverage, the description provides comprehensive context: it covers parameter semantics, code patterns, dependencies, security, performance, and debugging. It adequately compensates for missing structured fields, though the excessive length reduces usability.

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

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

With only 38% schema description coverage, the description compensates significantly by explaining parameter structure (name, dataTypeId, isOptional), common data type IDs, code parameter access patterns (input/output with alias handling), and validation options (validateIn/validateOut implications). It adds substantial meaning beyond the sparse 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 clearly states the tool's purpose: 'Creates or updates a JavaScript function within a server-side Business Object.' It specifies the verb (create/update), resource (Business Object Function), and scope (server-side). However, it doesn't explicitly differentiate from sibling tools like 'businessobject-function-delete' or 'businessobject-update' beyond the create/update 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 implies usage context through extensive development guidance (e.g., when to use dependencies, parameter validation patterns), but doesn't explicitly state when to choose this tool over alternatives like 'businessobject-update' or 'businessobject-function-test'. It provides best practices rather than direct usage rules.

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

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

Annotations indicate readOnlyHint=false (mutation), openWorldHint=true (flexible inputs), idempotentHint=false (non-idempotent), and destructiveHint=false (non-destructive). The description adds valuable behavioral context beyond this: it warns about the need to fetch the latest version before updates to avoid conflicts, clarifies that dependencies and tags must be resent during updates or they will be cleared, and specifies that dependencies are REQUIRED for certain API accesses. This enriches the agent's understanding of mutation risks and prerequisites.

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 well-structured with clear sections (attention notes, project assignment rules, example) and uses markdown formatting effectively. It is appropriately sized for a complex tool with 6 parameters, though it could be slightly more concise by integrating some schema-like details. Every sentence adds value, such as warnings about data preservation and project handling.

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 complexity (6 parameters, mutation operation, no output schema), the description is largely complete. It covers purpose, usage guidelines, critical behavioral nuances, and parameter semantics. However, it lacks details on the response format or error handling, which would be helpful since there's no output schema. The annotations provide safety context, but the description fills in practical gaps well.

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 schema description coverage at 67%, the description compensates significantly by explaining parameter semantics not fully covered in the schema. It details the critical role of dependencies (required for Simplifier.Connector.* or Simplifier.BusinessObject.* APIs), provides explicit rules for projectsBefore and projectsAfterChange parameters with creation vs. update scenarios, and includes a practical JSON example. This adds substantial meaning beyond the schema's basic property 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 explicitly states the tool's purpose: 'Create or update a Business Object.' It distinguishes this from sibling tools like businessobject-delete, businessobject-function-update, and connector-update by focusing on the core Business Object resource itself rather than functions, connectors, or deletion 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 provides explicit guidance on when to use this tool: for creating or updating Business Objects. It includes critical warnings about fetching the latest version before updates and resending dependencies/tags to avoid clearing them. It also distinguishes usage between creation (projectsBefore as empty array) and updates (projectsBefore as current assignments), offering clear alternatives within the tool's scope.

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

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

Annotations already indicate destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=true. The description adds value by explicitly stating the deletion action, which aligns with the destructive hint, but doesn't provide additional behavioral context like confirmation prompts, error handling, or system impacts beyond what annotations cover.

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

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

The description is a single, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose without unnecessary elaboration.

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 destructive nature (annotations cover this), two fully documented parameters, and no output schema, the description is adequate but minimal. It doesn't explain return values or error cases, which could be helpful for a deletion tool, leaving some gaps in 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?

With 100% schema description coverage, the input schema fully documents both parameters ('connectorName' and 'callName'). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline score of 3 for high schema coverage.

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 target resource ('a Connector call'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'connector-delete' or 'businessobject-delete', which would require explicit comparison to achieve a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'connector-delete' or 'connector-call-update', nor does it mention prerequisites or exclusions. It merely states what the tool does without contextual usage information.

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 adds valuable behavioral context beyond annotations: it explains that the tool executes calls with real data for testing, and the 'Important' note clarifies result filtering based on datatype and validateOut settings. Annotations already cover read-only, open-world, idempotent, and non-destructive traits, so the description complements them without contradiction, though it could mention more about error handling or limitations.

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 appropriately sized and front-loaded, starting with the core purpose. The bullet points and 'Important' note are structured for clarity, though the latter could be more concise. Every sentence adds value, but minor verbosity in the parameter explanation slightly reduces 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 the tool's complexity (testing with real data, 3 parameters, no output schema), the description is mostly complete: it covers purpose, usage, parameter details, and result filtering. However, it lacks information on output format, error handling, or prerequisites, which would enhance completeness for a testing tool without an output schema.

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

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

With schema description coverage at 33% (only one parameter has a description), the description compensates well by detailing parameter usage: it explains that parameters require 'name' and 'value', names must match defined parameters, and values can be any JSON value. This adds meaning beyond the sparse schema, though it doesn't fully cover all three parameters (e.g., connectorName and callName semantics).

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

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

The description clearly states the specific action ('Execute a connector call with provided input parameters for testing purposes') and resource ('connector call'), distinguishing it from sibling tools like connector-call-delete or connector-call-update. It explicitly mentions testing with real data to see results, making the purpose unambiguous and distinct.

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

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

The description provides explicit guidance on when to use this tool: for testing connector calls with real data to see results. It implicitly contrasts with sibling tools like connector-call-delete or connector-call-update by focusing on testing rather than modification or deletion, and the 'Important' note offers context on when results might be filtered, guiding usage decisions.

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

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

Annotations indicate readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: it warns about the need to fetch existing resources before updates to avoid data loss, explains that parameters must be resent during updates, and details connector-specific behaviors (e.g., REST requires at least one output parameter, SAPRFC calls should use wizards). No contradiction with annotations exists.

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 lengthy but well-structured with sections for each connector type. However, it includes extensive examples and XML snippets that may be excessive. The core information is front-loaded ('create or update a Connector call'), but the document could be more concise by summarizing connector-specific details rather than providing exhaustive documentation.

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 complexity (8 parameters, no output schema, rich annotations), the description is largely complete. It covers purpose, usage guidelines, behavioral nuances, and parameter semantics across connector types. However, it lacks explicit error handling or response format details, which would be helpful given the absence of an output schema.

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

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

With schema description coverage at 63%, the description compensates significantly by explaining parameter semantics for connector types (REST, SOAP, SAPRFC). It details parameter purposes (e.g., 'verb' for HTTP method, 'bindingName' for SOAP binding), formats (e.g., 'headParams/<http-header-name>'), and usage examples. This adds substantial meaning beyond the input schema's property 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 explicitly states the tool's purpose: 'create new connector calls' and 'modify existing connector calls.' It distinguishes from siblings like connector-call-delete and connector-call-test by specifying creation/update operations, not deletion or testing.

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 for when to use this tool: 'When updating a call, always fetch the existing resource first to ensure operating on the latest version.' It also mentions that 'Existing parameters have to be resent when doing an update - otherwise they would be cleared.' However, it doesn't explicitly state when NOT to use this tool or name specific alternatives for different 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?

Annotations provide rich behavioral hints (destructiveHint: true, idempotentHint: true, readOnlyHint: false, openWorldHint: true), so the bar is lower. The description doesn't contradict these annotations, and while it doesn't add much beyond the obvious 'delete' action, it implicitly confirms the destructive nature. However, it misses opportunities to clarify what 'delete' entails (e.g., irreversible removal, effects on dependencies) beyond what annotations cover.

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

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

The description is extremely concise with just four words ('Delete a Connector'), front-loading the core action and resource. There's zero wasted text, and it efficiently communicates the essential purpose without unnecessary elaboration, making it easy for an agent to parse quickly.

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

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

For a destructive deletion tool with no output schema, the description is minimal but adequate given the annotations cover key behavioral aspects (destructive, idempotent). However, it lacks context on prerequisites (e.g., authentication needs), side effects, or error handling, which could be important for safe invocation. The completeness is borderline, relying heavily on annotations to fill gaps.

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

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

Schema description coverage is 100%, with the single parameter 'connectorName' fully documented in the schema. The description adds no additional parameter information beyond what's in the schema, such as format examples or constraints. Given high schema coverage, a baseline score of 3 is appropriate as the description doesn't enhance parameter understanding but doesn't need to compensate for gaps.

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 verb ('Delete') and resource ('a Connector'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling deletion tools like 'businessobject-delete' or 'connector-call-delete', which would require specifying what type of connector is being deleted or how it differs from other deletable resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple deletion tools available (e.g., 'businessobject-delete', 'connector-call-delete', 'sap-system-delete'), there's no indication of what makes a 'Connector' distinct or when deletion is appropriate versus other operations like 'connector-update'. This leaves the agent without context for tool selection.

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 adds valuable behavioral context beyond what annotations provide. While annotations indicate this is a write operation (readOnlyHint: false) and not destructive, the description warns about data loss during updates ('Existing tags and endpoints have to be resent when doing an update - otherwise they would be cleared'), which is critical operational guidance not captured in annotations.

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

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

While well-structured with clear sections and examples, the description is quite lengthy (over 800 words) with extensive technical details. Some information could potentially be streamlined, though most content appears valuable for this complex tool. The purpose is front-loaded effectively.

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 high complexity (9 parameters, nested objects, 44% schema coverage, no output schema), the description provides comprehensive context. It covers connector types, SSL settings, update warnings, parameter interactions, and complete examples, making it sufficiently complete for an agent to understand and use this tool effectively.

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

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

With only 44% schema description coverage, the description compensates excellently by providing detailed parameter semantics. It explains connectorType-specific configurations (REST, SOAP, SAP RFC), sslSettings with trustType meanings, and provides complete JSON examples that clarify how parameters interact and should be structured, far exceeding what the sparse schema provides.

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

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

The description explicitly states the tool's purpose as 'create new connectors' and 'modify existing connectors', providing specific verbs and resources. It clearly distinguishes this from sibling tools like connector-delete and connector-call-update by focusing on creation and modification rather than deletion or testing.

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 guidance on when to use this tool for creation vs. update scenarios, including the important warning about fetching existing resources first when updating. However, it doesn't explicitly contrast when to use this versus alternatives like connector-wizard-rfc-create or other sibling tools, which prevents a perfect score.

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

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

Annotations indicate destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=false, covering key behavioral traits. The description adds context about the wizard process and prerequisites, but doesn't disclose additional behavioral details like rate limits, auth needs, or specific destructive effects beyond what annotations imply. No contradiction with annotations exists.

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 appropriately sized and front-loaded, starting with the main purpose and followed by concise usage steps. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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 complexity (destructive creation with prerequisites), annotations cover safety and behavior well, and schema coverage is complete. The description adds necessary context about the wizard and resource template, compensating for the lack of output schema. It's mostly complete but could briefly mention expected outcomes or error handling.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters. The description adds semantic context by explaining that connectorName refers to an RFC Connector and rfcFunctionNames are SAP system functions, but this mostly reinforces the schema without providing significant extra meaning like format examples or constraints.

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 calls for an RFC connector using a wizard, specifying the verb ('create'), resource ('calls'), and context ('RFC connector'). It distinguishes from siblings like connector-call-delete or connector-call-update by focusing on creation via a wizard, though it doesn't explicitly contrast with all 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?

The description provides clear context on when to use this tool: after finding available functions via a specific resource template and selecting desired function names. It implies prerequisites but doesn't explicitly state when not to use it or name alternatives among siblings, though the context is sufficient for typical usage.

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

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

The description adds valuable behavioral context beyond annotations: it explains the namespace prefix syntax and confirms the deletion action. While annotations already indicate destructiveHint=true and idempotentHint=true, the description reinforces the destructive nature and provides operational details not covered by structured fields.

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

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

Extremely concise with zero wasted words. Two sentences cover purpose, action, parameter meaning, and syntax details. The hash header provides clear structure, and every element serves a specific informational 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 destructive operation with no output schema, the description provides good coverage: purpose, parameter semantics, and namespace syntax. However, it doesn't mention potential side effects, confirmation requirements, or what happens to dependent objects, which would be helpful given the destructive nature.

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 description coverage and only one parameter, the description fully compensates by explaining what 'qualifiedName' represents (datatype name with optional namespace prefix separated by slash). It provides complete semantic understanding of the single parameter 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 specific action ('Deletes') and resource ('datatype with the given name'), distinguishing it from sibling tools like datatype-update. It provides precise scope by mentioning namespace prefixing with slash syntax, making the purpose unambiguous and well-differentiated.

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 through the namespace prefix explanation, but doesn't explicitly state when to use this tool versus alternatives like datatype-update or when deletion is appropriate. It provides some operational guidance but lacks explicit when/when-not directives or named alternatives.

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

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

The description adds valuable behavioral context beyond annotations: it explains the mutually exclusive nature of three key parameters (fields, collectionDatatype, derivedFrom) and namespace formatting rules. While annotations already indicate this is a destructive, non-idempotent write operation (destructiveHint: true, idempotentHint: false), the description provides specific implementation details about datatype creation logic.

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 efficiently structured with clear bullet points explaining the three datatype categories, followed by concise explanations of namespace conventions. Every sentence provides essential information with zero wasted words, making it easy to scan and understand.

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 complex tool with 7 parameters, nested objects, no output schema, and destructive annotations, the description does well covering the core datatype creation logic and parameter relationships. However, it doesn't explain the purpose of other parameters like tags, projectAssignments, or the qualifiedName format, leaving some gaps in understanding the full tool scope.

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 description coverage, the description carries the full burden of explaining parameters. It successfully explains the purpose and relationships of three critical parameters (fields, collectionDatatype, derivedFrom), their mutual exclusivity, and namespace formatting requirements for referenced datatypes. This adds substantial 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 explicitly states the tool's purpose as 'Create or update custom data types' with specific details about the three mutually exclusive datatype categories (struct, collection, domain). It clearly distinguishes this tool from its sibling 'datatype-delete' by focusing on creation/update rather than deletion.

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 about when to use specific parameters (mutually exclusive options for struct, collection, or domain types) and namespace conventions for connectors and business objects. However, it doesn't explicitly state when to use this tool versus alternatives like 'businessobject-update' or 'connector-update' which might handle related functionality.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing this as a safe read operation. The description adds valuable behavioral context beyond annotations: default behavior (50 most recent entries), pagination mechanics, time range constraints ('from/until must be used together'), and troubleshooting advice about server logging levels.

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 well-structured with clear sections (purpose, parameters, examples) and uses markdown formatting effectively. It's appropriately sized for a 6-parameter tool, though the parameter section could be more concise since it duplicates schema information. Most sentences earn their place by providing useful context.

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

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

For a read-only logging tool with comprehensive annotations and 100% schema coverage, the description provides good contextual completeness. It explains the tool's scope, filtering capabilities, default behavior, and includes practical examples. The main gap is the lack of output schema, but the description compensates by explaining what gets returned (log entries).

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

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

Schema description coverage is 100%, so the schema already fully documents all 6 parameters. The description's parameter section largely repeats what's in the schema (though it adds the log level mapping 0-4). The examples provide some additional usage context, but overall the description adds limited value beyond the comprehensive 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: 'Get recent log entries from Simplifier' with specific verb ('Get') and resource ('log entries'). It distinguishes itself from sibling tools (which are all businessobject/connector/datatype CRUD operations) by focusing on logging system access.

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 about when to use it ('filter logs by level and time range') and what happens with no filters ('returns the 50 most recent log entries'). It also includes troubleshooting guidance for missing logs. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings.

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

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

The description adds valuable behavioral context beyond annotations. Annotations indicate this is a mutable, non-destructive operation (readOnlyHint: false, destructiveHint: false), but the description elaborates on update semantics, type immutability constraints, and provides specific examples for different authentication scenarios. It also mentions prerequisites like discovering OAuth2 clients, which adds practical implementation guidance.

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 excessively long (over 150 lines) with redundant information. While well-structured with sections for each authentication type, it includes multiple repetitive examples and could be significantly condensed. The core concepts could be communicated in a fraction of the length without losing essential information.

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

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

For a complex tool with 18 parameters and no output schema, the description provides comprehensive coverage of authentication types, source configurations, and usage patterns. It addresses the main complexity areas through detailed examples. The main gap is the lack of information about return values or error conditions, but given the tool's complexity, the description does an above-average job of providing 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?

Despite 100% schema description coverage, the description adds substantial value through comprehensive examples that illustrate parameter combinations for different authentication types. It provides concrete JSON configurations for UserCredentials, OAuth2, Token, and SAPSSO methods with various source types, showing how parameters interact in real-world scenarios far beyond what the schema descriptions provide.

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: 'Create or update login methods for authenticating connectors with external systems.' It specifies the verb (create/update) and resource (login methods), and distinguishes from siblings by focusing on authentication configuration rather than business objects, connectors, or other system components.

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 some usage context by listing supported authentication types and noting that 'the type of a login method cannot be changed later,' but it doesn't explicitly state when to use this tool versus alternatives. While it mentions discovering OAuth2 clients before creation, there's no guidance on when to choose this tool over other authentication configuration methods or when not to use it.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, which the description doesn't contradict. The description adds minimal context by specifying 'existing SAP system,' implying it won't work for non-existent systems, but doesn't elaborate on permissions, confirmation requirements, or recovery options beyond what annotations provide.

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 zero waste. Every word contributes directly to stating the tool's purpose without unnecessary elaboration.

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 destructive nature (per annotations) and lack of output schema, the description is minimally adequate but incomplete. It doesn't address potential side effects, error conditions, or what happens post-deletion, which would be valuable for a destructive operation.

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

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

Schema description coverage is 0%, with one parameter 'name' undocumented in the schema. The description doesn't add any parameter details beyond what's implied by the tool name, failing to compensate for the coverage gap. Baseline 3 applies as the schema provides structure but no 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 the action ('Delete') and target resource ('an existing SAP system'), providing specific verb+resource pairing. However, it doesn't explicitly differentiate from sibling tools like 'sap-system-update' or other delete operations, which would be needed for a perfect score.

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. With sibling tools like 'sap-system-update' and multiple other delete operations, there's no indication of prerequisites, appropriate contexts, or when-not-to-use 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?

The description adds valuable behavioral context beyond annotations: it warns about tag clearing during updates (requiring fetching the latest version first) and explains project assignment logic. Annotations already indicate this is a destructive, non-idempotent write operation (destructiveHint: true, idempotentHint: false), but the description provides specific implementation details that help the agent use the tool correctly.

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 well-structured with clear sections (purpose, attention warning, resource references, project assignment rules, example). While somewhat lengthy, every section serves a purpose: the warning about tags is crucial, the project assignment explanation is necessary for correct usage, and the example clarifies complex parameter interactions.

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 complex tool with 9 parameters, nested objects, no output schema, and destructive annotations, the description provides substantial context: it explains the tool's role in the ecosystem, gives implementation warnings, details project assignment logic, and provides usage examples. The main gap is lack of information about return values or error handling, but overall it's quite 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?

With 67% schema description coverage, the description compensates well by explaining critical parameter semantics: it details the purpose and usage of 'projectsBefore' and 'projectsAfterChange' parameters with clear examples, and provides important warnings about 'tags' parameter behavior during updates. This adds significant value beyond the schema's technical 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 the tool's purpose as 'Create or update a SAP system' and explains that SAP Systems are used as targets for RFC connectors. It distinguishes from siblings like 'sap-system-delete' by focusing on creation/update operations rather than deletion.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: it references finding existing systems with 'simplifier://sap-systems' and details with 'simplifier://sap-system/{systemName}'. It also gives clear instructions for creating vs. updating scenarios, including project assignment rules and tag handling warnings.

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