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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses autoActivate defaulting to true, distinguishes 'success' from 'activated', explains the internal read/insert/save flow, and notes the caller avoids large XML handling. This is unusually transparent 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 compact and front-loaded with the most decision-relevant fact ('Atomic edit'). Every sentence adds value: operation, activation semantics, and internal mechanism. There is no filler or repetition of schema content.

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

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

For a tool with 14 parameters, no annotations, and no output schema, this description leaves too much unresolved: most parameter meanings, the exact response shape beyond the success/activated distinction, and any explicit guidance about which sibling to use instead. An agent would likely need external documentation or trial and error.

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 only 14%, yet the description adds meaningful parameter context only for autoActivate and the general notion of 'field'. The remaining 12 parameters such as label, scale, length, dataType, precision, transport, and semanticType are undocumented in both the schema and description, so the description does not compensate for the low 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 names a specific operation and resource: 'add a local 'field'-type field to an ADSO and save'. The qualifier 'local field-type' and the atomic edit framing clearly separate this from broader ADSO creation, deletion, or XML retrieval siblings.

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

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

The 'Atomic edit' and 'no large XML handling by the caller' phrasing give clear context for when this tool is appropriate: small, focused field additions without manual XML plumbing. It does not explicitly name alternatives or state when not to use it, so it stops short of full routing 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 carries the full burden of behavioral disclosure. 'Check' suggests a read-only validation operation, but the description does not state whether it performs a syntax check, a consistency check against metadata, a runtime check, or whether it has side effects. It also does not disclose what happens on failure or what the output looks like.

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

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

The description is extremely short, which is concise, but it is under-specified rather than efficiently informative. It is front-loaded with the verb 'Check', but the single phrase does not earn its place because it leaves too much ambiguity.

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 required parameter, no output schema, and no annotations, the description is incomplete. An agent cannot determine what input to provide, what the tool returns, or how to interpret the result. The sibling context shows many similar ADSO tools, so more detail is needed to avoid mis-selection.

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 undocumented 'id' parameter. The description only says 'Check ADSO consistency' and does not explain what 'id' refers to (e.g., ADSO name, technical name, UUID) or how it is used. With one required parameter and no schema description, 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 'Check ADSO consistency' uses a verb and a resource, but 'consistency' is vague and does not specify what is checked, what result is produced, or how it differs from sibling tools like bw_adso_details, bw_adso_versions, or bw_adso_get_xml. It is not a tautology, but it lacks enough specificity to distinguish it from other ADSO inspection 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 guidance is given about when to use this tool versus alternatives. The sibling list contains many ADSO-related tools (bw_adso_details, bw_adso_versions, bw_adso_get_xml, bw_adso_transformations, bw_adso_dtps), and the description does not explain what makes 'check' the right choice. The context is implied at best.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, permission requirements, validation behavior, or what happens on conflicts. For a state-changing creation tool, this is a significant gap.

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

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

A single sentence that directly states the purpose and the required fields. No filler, front-loads the key information, and efficiently communicates the core action and the next step.

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 creation tool with 12 parameters, a nested template object, and no output schema, this description is too sparse. It omits return value details, activation behavior (though schema has defaults), preconditions, and how it fits with the broader tool family beyond the field-add step. The minimal hint about the follow-up tool is helpful but leaves critical context unaddressed.

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 only 42%, so many parameters (template, readOnly, activateData, writeChangelog) lack inline descriptions. The description merely lists the required fields without adding meaning beyond the schema's required array. It does not explain what name, description, or infoArea represent or how they are used, failing to compensate for the schema 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?

Description names a specific verb ('Create') and resource ('empty ADSO shell'), and explicitly says fields are added later via bw_adso_add_field, which distinguishes it from other ADSO tools like bw_adso_details or bw_adso_get_xml. It clearly identifies this as the creation step in a multi-step process.

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

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

Provides a usage hint by naming the follow-up tool (bw_adso_add_field) and indicating that fields are added after creation. However, it does not explicitly state when to use this vs. other creation tools (e.g., bw_area_create, bw_trfn_create) or any exclusions. The context is implied rather than 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 must disclose behavior itself. It does say the result is 'parsed,' that the payload may include configuration, DDIC tables, and links when the enriched client path is available, and that otherwise a standard details projection is returned. This is useful, but it does not state whether the operation is read-only, what the response shape is, or how the enriched path is determined.

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

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

The description is compact at two sentences and leads with the core purpose. 'Prefer outputPath' is terse to the point of ambiguity, but it does not waste words. Each sentence contributes meaningful information, though the instruction could be clearer.

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 no annotations, no output schema, and many similar siblings, the description leaves important gaps: id and forceCacheUpdate are unexplained, the return projection is vague, and no alternative tools are mentioned. The rich outputPath schema note helps, but the overall definition is not complete enough for an agent to call this confidently without further inference.

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 only 33%, and the main description does not compensate. It never explains what 'id' refers to or what forceCacheUpdate controls. 'Prefer outputPath' hints at outputPath's importance, but the description leaves the required parameter and the boolean semantics undocumented, placing too much burden on the sparse 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 first sentence gives a specific verb and resource: 'Get parsed ADSO metadata (fields, indexes, partitioning).' This clearly identifies what the tool does and distinguishes it from raw-XML or transformation-focused siblings like bw_adso_get_xml and bw_adso_transformations. However, it does not explicitly name any sibling or contrast itself with similar *_details tools, so it stops short of full differentiation.

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

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

There is no guidance on when to choose this tool over alternatives such as bw_adso_versions, bw_adso_transformations, or bw_adso_get_xml. 'Prefer outputPath' is a parameter-level instruction rather than a tool-selection guideline. The enriched-path conditional describes behavior, not usage context, so the agent is left to infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose a meaningful output trait: each DTP title includes a 'SOURCE -> TARGET' relation, which helps set expectations. However, it does not explicitly state whether this is a read-only operation, how name matching behaves, or what the complete return structure looks like without outputPath.

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 exceptionally concise: two short sentences with no filler. The primary purpose is front-loaded in the first sentence, and the second sentence adds a valuable output detail. Every word earns its place.

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

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

For a simple lookup tool with no output schema, the description gives enough to understand the main result (DTP titles with SOURCE -> TARGET relations) and how to invoke it (adsoName). However, it lacks details about matching behavior, empty results, pagination, or the exact response envelope, which would be valuable given the absence of an output schema and annotations.

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 input schema already fully documents both adsoName and outputPath. The description adds no significant parameter semantics beyond the schema; it only hints at the adsoName usage through 'via name search'. With full schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the action ('Get DTPs') and the resource scope ('related to an ADSO'), with a specific search method ('via name search'). The second sentence adds useful clarification about the SOURCE -> TARGET relation carried by each DTP title. It is slightly vague about what 'related to' means exactly, but the relation hint helps distinguish this from other ADSO/DTP tools.

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

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

The description implies when to use the tool: when you need DTPs associated with an ADSO by name search. However, it does not explicitly mention alternatives, exclusions, or when not to use this tool compared to sibling tools like bw_dtp_details or bw_adso_transformations. The usage context is clear but not elaborated.

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 discloses response envelope shape with and without outputPath, the disk-write behavior, the raw-XML plain-text file format, and the read-only role in a read-modify-write flow.

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?

Front-loaded with the core purpose, then prioritized usage guidance, then parameter behavior. Every sentence carries distinct operational information with 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?

Very complete for a read tool with no output schema: it covers output handling, formats, response envelope, and downstream integration. The only substantive gap is the undocumented forceCacheUpdate parameter.

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 description adds substantial meaning beyond the schema for outputPath and format, including file contents, reuse as xmlPath, and inline response behavior. However, forceCacheUpdate is not explained in either the schema or the description, preventing a perfect score.

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

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

States a specific verb and resource: 'Get the raw ADSO XML used for PUT updates,' and anchors it as 'Step 1 of read-modify-write.' This clearly distinguishes it from other get_xml siblings by ADSO 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?

Explicitly says 'ALWAYS prefer outputPath' for 15–80 KB payloads, explains when to use inline format instead, and contrasts with other *_get tools that write parsed JSON rather than raw XML. It also names the downstream reuse in bw_adso_save_and_activate.

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 disclosure burden, and it does disclose genuine behavior: the tool locks, PUTs, optionally activates, then unlocks — side effects an agent cannot infer from the schema alone. It also discloses return behavior ('Returns a compact projection') and the hard constraint 'Do not omit both'. It stops short of a 5 because failure/rollback semantics (e.g., what happens if activation fails after PUT) and permission requirements are not disclosed for this 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?

Four sentences in roughly 90 words, with the highest-value summary ('lock → PUT → (optional) activate → unlock') front-loaded first. Every sentence earns its place: workflow, xml guidance, transport constraint, and return behavior. No filler or restatement of schema content.

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

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

For a complex mutation tool with 9 parameters, zero annotations, and no output schema, the description covers the three critical decision points an agent must get right: XML source selection, transport provisioning, and output handling. It partially compensates for the missing output schema by describing the compact projection. It is not quite a 5 because error conditions (missing transport failure mode) and post-failure state are left unspecified.

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 78%, near the high-coverage baseline of 3, and the description adds real cross-parameter meaning beyond the schema: the preference rule between xmlPath and xmlContent for large bodies, the XOR constraint between transport and createTransport, and the outputPath tradeoff (compact projection vs full detail). These add value beyond the individual 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 states a specific multi-step workflow — 'One-stop: lock → PUT → (optional) activate → unlock' — with an identifiable resource (ADSO, from the tool name). It is clear about what the tool does, though it never literally says 'save and activate an ADSO' and relies on the name for the resource. It does not explicitly differentiate from the sibling save_and_activate family (bw_trfn_save_and_activate, bw_dtp_save_and_activate), so it falls short of full sibling 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 gives actionable when-to guidance: 'Prefer xmlPath ... over inline xmlContent for large bodies' and the transport requirement rule ('pass transport=<existing TRKORR> OR createTransport=true ... Do not omit both'), even routing to bw_transport_check for listing requests. However, it provides no explicit when-not-to-use or alternatives (e.g., when to use bw_adso_check or bw_adso_create instead), so exclusions are absent.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that lookup is by name search and that TRFN titles encode SOURCE -> TARGET, but it does not describe pagination, return shape, error behavior, or whether the ADSO can appear on either side of the relation.

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

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

Two sentences, front-loaded with the action and resource, and the second sentence adds a genuinely useful output-semantic detail. No filler or schema 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?

For a simple two-parameter get tool the description covers the core entity and a key semantic, and outputPath is fully described in the schema. Still, with no output schema it leaves return structure and matching behavior somewhat underspecified, making it minimally viable rather than complete.

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

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

Schema coverage is 100%, and outputPath is already documented in detail inside the schema. The description adds only the 'name search' nuance for adsoName, which is helpful but not required; baseline 3 is appropriate.

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

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

The description names a specific verb and resource ('Get Transformations related to an ADSO') and adds the search mechanism ('via name search'). It does not explicitly name a sibling to contrast with, so it stops short of full differentiation, but an agent can tell this from DTP/dataflow tools.

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

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

The intended context is implied: use this when you need transformations associated with an ADSO, especially since each TRFN title exposes a SOURCE -> TARGET relation. However, it gives no explicit when-not-to-use guidance or alternatives such as bw_adso_dtps, bw_trfn_details, or bw_dataflow_get.

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. 'Validate that an InfoArea exists' conveys that this is a read-only existence check and 'pre-create' implies no mutation, which is useful. It does not disclose return shape, failure behavior, or connection prerequisites, but the validation/pre-create wording covers the core behavioral profile.

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

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

Two short sentences with zero filler. The primary purpose is front-loaded and the alternative-routing note is tightly expressed.

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

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

For a one-parameter existence check with no output schema, this description gives the agent what it needs: the operation, the call context, and the alternative for broader workflows. Only explicit return/error semantics are missing, which is minor for a validation 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%, but the description lets an agent infer that 'name' refers to the InfoArea to validate. That adds meaning beyond the raw string type, though it does not specify naming conventions or expected format.

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

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

The description states a specific action, 'Validate that an InfoArea exists', and scopes it as a pre-create check for ADSO. It also names the sibling for the general workflow, so an agent can distinguish this tool from bw_area_validate_exists without opening schemas.

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

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

The description explicitly says 'Prefer bw_area_validate_exists for InfoArea workflows', naming the alternative and the condition that selects it. It also frames this tool's intended context as a pre-create check for ADSO, leaving no ambiguity about when 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the validation purpose. It does not say whether the tool is read-only, what 'available' means (e.g., duplicate name, naming convention), what it returns, or whether any side effects occur.

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 redundant phrasing. Every word contributes to the core meaning, making it appropriately concise for a simple one-parameter validation tool.

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 no annotations and no output schema, so the description needs to explain return behavior and call context, but it does neither. An agent cannot tell what a successful or failed validation looks like, or what prerequisites exist, making the definition under-specified.

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 undocumented string parameter and 0% schema description coverage, so the description must compensate. It adds only that the parameter is an ADSO name, but gives no format, length, character restrictions, or distinction between technical name and description.

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

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

The description states a clear verb ('Validate'), resource ('ADSO name'), and condition ('available'), so an agent can tell this is a name-availability check. It does not explicitly differentiate from sibling validation tools like bw_adso_validate_info_area or bw_area_validate_new_name, but the resource and intent are 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 given about when to use this tool versus alternatives such as bw_adso_validate_info_area, bw_adso_validate_template, or bw_infoobject_validate_new_name. The description implies it should be used before creating or naming an ADSO, but this is not stated explicitly.

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

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

With no annotations provided, the description must disclose behavioral traits. It only states the intent to validate existence but does not reveal the response format (e.g., boolean, error), side effects (likely none, but not stated), or behavior when the template ADSO does not exist. This is a significant gap for a validation 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 fluff or redundancy. It is appropriately front-loaded with the key action and object, earning full marks for conciseness.

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

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

For a simple one-parameter validation tool, the description is incomplete. It lacks any information about the return value or error behavior, and does not explain when this validation is needed or how it integrates with other ADSO operations. Given the absence of an output schema and annotations, the description leaves essential operational details undefined.

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

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

The schema has zero description coverage for the only parameter 'name', so the description must explain it. It does not explicitly state that 'name' is the template ADSO name, nor does it clarify format or naming conventions. The connection is implied but not stated, leaving room for misinterpretation.

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 (validate) and the object (that a template ADSO exists). It is specific to template ADSOs, distinguishing it from validation tools for new names, info areas, or other object types. However, it does not explicitly name alternatives or contrast with siblings, so it is clear but not fully 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?

No guidance is provided on when to use this tool versus other validation tools like bw_adso_validate_new_name or bw_area_validate_exists. There is no mention of context, 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a non-mutating 'get' operation, but it does not explain what the version history contains, how it is ordered, whether it returns full details or just summary entries, or any potential 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 a single front-loaded sentence with zero filler, making it very concise. However, the brevity comes at the cost of omitting useful contextual details that would help an agent use the tool confidently.

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 this is a simple one-parameter tool, the absence of annotations, output schema, parameter elaboration, and usage guidance leaves an agent to infer both the meaning of 'id' and the shape of the returned version history. The description is not fully actionable on its own.

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 undocumented 'id' parameter, but it does not. The name 'id' and the ADSO context imply the parameter identifies an ADSO, but the description never states what the id refers to, its required format, or that it is required.

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 verb ('Get') and resource ('ADSO version history'), so an agent can tell this is a retrieval operation for ADSO version data. It does not explicitly differentiate from sibling version tools like bw_datasource_versions or bw_trfn_versions, but the ADSO qualifier makes the target object clear.

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 such as bw_adso_details, bw_adso_get_xml, or the version-history tools for other object types. There are no prerequisites, typical use cases, or exclusions provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses the internal sequence (validate, lock, POST, unlock), explicitly notes 'no activate', and mentions the transport behavior for $TMP packages. This is meaningful behavioral context beyond what the schema shows. It doesn't mention side effects like whether the lock is released on error, but the disclosed flow is substantial.

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

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

Three sentences with zero waste. The core action is front-loaded, the flow is compactly listed, and the transport note is a single practical sentence. Every sentence earns its place.

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

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

For a create tool with 8 parameters, 100% schema coverage, and no output schema, the description covers the essential behavioral context: the flow, the no-activate behavior, and the transport note. It doesn't describe the return value, but with no output schema and a create operation, the main gaps are minor. The description is complete enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters. The description adds context about the parent InfoArea relationship and transport behavior, but doesn't add per-parameter semantics beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Create an InfoArea under a parent InfoArea.' It clearly identifies the object type (InfoArea) and the hierarchical relationship (under a parent). It doesn't explicitly differentiate from sibling tools like bw_area_validate_exists or bw_area_get_xml, but the create action is distinct enough among the area-related siblings.

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

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

The description provides a clear flow ('validate parent → validate name → lock → POST → unlock') and a usage note ('$TMP packages typically need no transport'). This gives context on when to use the tool and what to expect. It doesn't explicitly state when NOT to use it or name alternatives, but the flow and transport note provide practical 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?

The description goes beyond the schema by disclosing the lock/unlock sequence, the underlying HTTP call (DELETE /a?lockHandle=…), and irreversibility. For a destructive operation with no annotations, this is strong behavioral disclosure, though it does not mention cascading effects or permissions.

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 three short, purposeful sentences: purpose, lock/delete/unlock behavior, and irreversibility. Every sentence earns its place and the most important information is 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?

For a one-parameter tool with no output schema, the description covers the operation, the locking behavior, and the destructive consequence. It does not describe return values or error behavior, but that is not essential given the simplicity of the tool.

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

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

The input schema fully describes the only parameter ('InfoArea technical name to delete'), and the description adds no additional parameter-level meaning. With 100% schema description coverage, the baseline of 3 applies.

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

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

The description uses a specific verb ('Delete') and a specific resource ('InfoArea'), so an agent immediately knows the target. It does not explicitly contrast with sibling tools like bw_object_delete, but the operation is clear 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?

No guidance is given for when to choose this tool over alternatives such as bw_object_delete, or when not to use it. The intended use is implied by the name and description, but there is no explicit context, prerequisite, or exclusion.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does this well: it states the active version (/a), explains the outputPath side effect (writes a file and returns a summary envelope), describes the raw-XML-versus-JSON distinction, and notes that pagination/projection is skipped when outputPath is set. This is substantial behavioral context beyond a generic 'get XML' statement.

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

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

The description is concise and front-loaded with the core purpose. The second sentence, however, is somewhat cryptic and references a hypothetical future save tool, which slightly hurts clarity. It is compact but not perfectly clean.

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 get-style tool with three parameters, no output schema, and no annotations, the definition is complete enough for an agent to invoke it correctly. It covers what the tool returns, how format affects inline responses, when to use outputPath, what the outputPath envelope contains, and how this tool fits into the broader get_xml family. No critical invocation details are missing.

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

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

The schema already covers all three parameters with descriptions, so the baseline is 3. The tool description adds meaningful extra semantics: it reveals that the returned XML is the active version (/a), advises preferring outputPath, and hints that output can later be reused as xmlPath. Those additions justify one point above the baseline.

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 opens with a specific verb+resource+output: "Get InfoArea raw XML (active version /a)." This makes the tool's purpose immediately clear and scopes it to a particular object type (InfoArea) and output format (raw XML), distinguishing it from create tools and from get_xml tools for other object types like ADSO, transformation, and DTP.

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: "Prefer outputPath," and clarifies that create tools use structured parameters rather than raw XML. The outputPath schema description adds strong routing guidance, telling agents to use the matching bw_*_get_xml family when raw XML is needed versus parsed XML-to-JSON tools. However, the guidance about "Reuse as xmlPath only if a future save tool is added" is conditional and speculative, so it is not a fully crisp when-to-use vs. when-not-to-use statement.

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 disclosure burden. It conveys a non-mutating validation operation, but it does not state the return contract, error behavior, or explicitly confirm the tool is read-only. The core behavior is present, but the details are thin.

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

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

Two short sentences with no filler. It front-loads the purpose and then provides a useful alternative-preference note. The description is appropriately sized for such a simple tool.

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

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

For a one-parameter existence check with no output schema, the description is largely complete: it identifies the object type and the preferred sibling. The only minor gap is not specifying what the validation returns or how failure is signaled.

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 already fully documents the single 'name' parameter with 100% coverage, including its type and meaning as the InfoArea technical name. The description adds no additional parameter detail, but none is needed because the schema is sufficient.

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 and resource: 'Validate that an InfoArea exists (AREA).' It also distinguishes itself from the sibling bw_adso_validate_info_area by explicitly recommending this tool over it, making the tool's scope immediately clear.

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 explicitly tells the agent to prefer this tool over bw_adso_validate_info_area, which is a clear routing instruction against a specific alternative. For a single-purpose existence-validation tool, this is sufficient usage 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 carries the full burden of disclosing behavior. It only states what the tool validates, but does not indicate whether it is read-only, what it returns (e.g., boolean, error), or how it handles invalid or duplicate names. This is a significant gap for a validation 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, efficient sentence with no fluff. It conveys the core purpose immediately. However, it could be slightly more informative without bloating, such as noting the validation criteria or return type, but conciseness is not a major issue.

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 validation tool with no output schema and no annotations, the description is incomplete. It does not mention the return format (e.g., boolean, error message), success/failure behavior, or any constraints on naming conventions. An agent cannot fully anticipate the tool's response, which is a notable omission.

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 already documents the 'name' parameter with the description 'Candidate InfoArea name.' (100% coverage). The tool description adds no additional meaning beyond that, so it does not compensate further. Baseline 3 is appropriate since schema does the heavy lifting.

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

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

The description clearly states the action ('Validate') and the resource ('new InfoArea name'), with a specific condition (availability). It distinguishes itself from siblings like bw_area_validate_exists (which presumably checks existing areas) and bw_area_create (which creates). The purpose is unambiguous and specific.

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 such as bw_area_validate_exists or bw_area_create. There is no mention of prerequisites, context, or exclusions. The agent is left 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?

With no annotations provided, the description carries the full burden, but it only mentions level expansion and suggests outputPath. It does not disclose that outputPath writes a file to the workdir and returns a summary envelope, nor does it describe side effects or safety implications of the 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 short, front-loaded with the core purpose, and has no filler. It loses a point because the levels and outputPath sentences largely repeat what the input schema already documents.

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 5 parameters, no output schema, and no annotations, so the description must be reasonably complete. It gives the core function and key behavior, but leaves the normal return shape, default direction, and relationship to bw_dataflow_lineage implicit. The schema fills most gaps, making it adequate but not fully complete.

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

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

Schema description coverage is 80%, so the baseline is 3 even without parameter elaboration in the description. The description's levels sentence restates the schema wording and adds no new meaning, and the outputPath advice duplicates schema guidance.

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 ('Get') and resource ('dataflow/lineage graph') and specifies nodes + relations. However, it does not distinguish this tool from the sibling bw_dataflow_lineage, which appears to overlap in purpose, so it is clear but not fully 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?

Usage is implied: call this when you need a dataflow/lineage graph around an object. It offers parameter-level guidance ('Use outputPath for deep graphs'), but it does not provide explicit when-to-use vs alternatives or exclusions, especially relative to bw_dataflow_lineage.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does not mention whether the operation is read-only, what the result format is (e.g., a list, graph, JSON), or any potential side effects or cost. The agent has no clue about the return structure or performance implications, which is a significant gap.

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

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

The description is a single sentence with an embedded example, which is efficient and front-loaded with the core purpose. There is no redundancy or filler. However, it omits important behavioral context that could have been added without bloating the text, so it loses a point for under-specification.

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 (4 parameters, no output schema, no annotations), the description is insufficiently complete. It does not describe the return format, pagination, error conditions, or when to use outputPath. For an agent to call this correctly, it needs more information about what the result looks like and how to interpret it.

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

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

Schema description coverage is 100%, so source and target are documented as 'Source object name' and 'Target object name'. The description does not add extra meaning beyond the schema—it repeats the linking concept but provides no additional syntax, format, or context for parameters like targetType. Baseline 3 is appropriate because the schema already handles 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 states a clear purpose: 'Find transformations and DTPs linking a source object to a target object' with a concrete example. This distinguishes it from sibling tools like bw_adso_transformations (which likely lists all transformations for a single ADSO) by explicitly focusing on source-to-target lineage pairs. The verb 'find' and resource 'transformations and DTPs' are specific.

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 such as bw_adso_transformations or bw_adso_dtps. There is no mention of when not to use it, prerequisites, or typical scenarios beyond the example. The agent must infer usage from the sibling names and context.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It mentions 'parsed' details and the outputPath behavior (writing full results to a file, returning a summary envelope), which provides useful behavior insight. However, it doesn't mention read-only nature or side effects, but "Get" implies read-only.

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 short, which is concise, but it undersells the tool's capability. The outputPath parameter's description is long but that's part of the schema. The main description lacks structure and detail, though it is front-loaded with the primary 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 the tool is not overly complex and has no output schema, the description provides a basic understanding. However, without annotations or more details on return format, prerequisites, or examples, it's moderately incomplete. The outputPath detail helps but doesn't cover all aspects.

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 low (25%), but the outputPath parameter has a rich description explaining its purpose and behavior. The description itself adds context about 'parsed' details. Other parameters (datasource, sourceSystem, forceCacheUpdate) lack description-level context, so the description adds some 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 'Get parsed DataSource details' but is brief and doesn't differentiate from siblings like bw_datasource_get_xml or bw_datasource_fields. The core purpose is clear even without sibling comparison.

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

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

The description mentions 'Prefer outputPath' without explaining when to use it vs. not. It implies usage context but lacks explicit guidance on when this tool is preferred over 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?

With no annotations, the description carries the full burden of behavioral disclosure. Saying 'Get parsed DataSource field list' only states the high-level read behavior; it does not explain caching, forceCacheUpdate effects, output structure, or any prerequisites, which is a meaningful gap for a tool with four unannotated 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 phrasing. While sparse, its brevity is not padded with filler; however, it may be slightly too terse to stand alone for such an under-documented tool.

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 four parameters, no output schema, and no annotations, a one-line description is not complete enough. It does not explain what the returned field list looks like, what sourceSystem must contain, or what forceCacheUpdate does, so an agent lacks critical 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 only 25%: only outputPath is documented in the schema. The description adds no meaning for datasource, sourceSystem, or forceCacheUpdate, so the agent is left without enough context about what these required parameters mean or how they affect the operation.

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 action ('Get') and resource ('parsed DataSource field list'), so an agent can tell it returns field information rather than raw XML or metadata. It doesn't explicitly name or differentiate it from sibling getters like bw_datasource_details or bw_datasource_get_xml, but the object is specific enough to be 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?

There is no guidance on when to use this tool versus alternatives such as bw_datasource_get_xml, bw_datasource_details, or bw_datasource_versions. No exclusions or preferred contexts are mentioned, leaving the agent to infer usage solely from the tool name and sibling list.

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

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

With no annotations, the description carries the burden and it discloses the key behaviors: get operation, file output when outputPath is set, inline summary vs raw XML otherwise, and reusability of the written XML. It does not describe the default format when format is omitted or the effect of forceCacheUpdate, but these are less central than the main behavior.

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

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

Three sentences with the key workflow and format decisions front-loaded. The 'ALWAYS prefer outputPath' directive is direct, and no sentence is wasted.

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?

Core behavior is covered well, but with no annotations and no output schema, the definition still leaves forceCacheUpdate and sourceSystem undefined and doesn't state the inline default when format is absent. For a 5-parameter tool with low schema coverage, these are meaningful 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 coverage is only 40%, and the description mostly clarifies outputPath and format, leaving the required sourceSystem and the forceCacheUpdate boolean undocumented in both schema and description. It does add concrete meaning for format (summary vs xml), but it does not compensate for the low coverage of the remaining 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?

States a specific verb and resource ('Get raw DataSource XML') and the intended workflow ('for PUT updates'), so an agent knows this is the datasource read-for-edit tool. It doesn't explicitly contrast with sibling get_xml tools (bw_adso_get_xml, bw_trfn_get_xml, etc.), though the resource name and 'DataSource' make the target object clear.

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?

Gives a strong directive ('ALWAYS prefer outputPath') and explains the outputPath workflow: write full XML to disk and reuse it as xmlPath in bw_datasource_save_and_activate. It also states the inline format alternatives (summary vs xml) and the schema adds the explicit rule to use a bw_*_get_xml tool when raw XML is needed.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses that the tool returns merged XML rather than persisting it ('write it back via save_and_activate'), which is useful. However, it does not mention side effects, failure conditions, or whether any datasource state is modified before the explicit save step.

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

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

Two sentences deliver the purpose, usage preference, return value, and required follow-up action with no filler. The most important behavioral instruction is front-loaded in the first sentence.

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

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

The description covers the main action, output, and next step, and the schema adds useful parameter details. However, there is no output schema, no annotations, and no explanation of the required datasource/sourceSystem parameters or edge cases. It is workable but not fully complete for safe 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 schema documents xmlPath, xmlContent, and outputPath, but the two required parameters, datasource and sourceSystem, have no descriptions. The description adds meaningful parameter guidance by explaining precedence and recommending outputPath for large merged XML, and it references bw_*_get_xml with outputPath. Still, it does not fully compensate for the required-parameter documentation 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 uses a specific verb and resource: 'Merge an ODP proposal ... into the current DataSource XML.' It also states the outcome ('returns the merged XML') and the follow-up action, clearly distinguishing it from read-only tools like bw_datasource_get_xml or persistence tools like bw_datasource_save_and_activate.

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 clear context for when this tool is relevant ('after adapter change'), explicitly prefers xmlPath over inline xmlContent, and directs the caller to write the result back via save_and_activate. It does not explicitly list when-not-to-use scenarios or name alternative merge tools, but the workflow guidance is strong.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals the operation sequence, the transport condition, and the compact return projection, which is useful. It does not mention side effects, required permissions, lock scope, or failure behavior, but it does not contradict any 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?

Three dense, front-loaded sentences: workflow first, then parameter preference, then transport rule. There is no filler and every sentence adds decision-relevant 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 9-parameter mutation tool with no annotations and no output schema, the description leaves notable gaps: the meaning/format of datasource and sourceSystem, the default behavior of autoActivate, transportDescription semantics, and what exactly the compact projection contains. It is adequate but not complete.

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

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

Schema descriptions cover only 3 of 9 parameters (33%), so the description must compensate. It adds meaningful semantics for xmlPath vs xmlContent and the transport/createTransport choice. However, datasource, sourceSystem, autoActivate, and transportDescription remain semantically 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 conveys a concrete sequence (lock → PUT → optional activate → unlock) for a datasource save-and-activate operation, which is identifiable from the tool name and parameter names. It does not explicitly contrast with the sibling *_save_and_activate tools, but the resource and workflow are clear.

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 actionable guidance: prefer xmlPath produced by bw_datasource_get_xml + outputPath over inline xmlContent, and choose between passing transport=<TRKORR> or createTransport=true when a transport is required. It does not state when to avoid this tool or when a different save/activate sibling would be more appropriate.

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

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

With no annotations provided, the description must carry the burden of behavioral disclosure. 'Get' implies a read operation, but the description does not state side effects, authorization needs, response format, or whether any mutation could occur. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence with no redundant wording. It is efficient, though it may be too sparse to fully support tool selection and invocation; the 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?

For a tool with no output schema, no annotations, and undocumented parameters, the description is incomplete. It does not clarify what the version history contains, how to identify a DataSource, or what the response looks like, leaving important gaps 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 does not mention or explain either 'datasource' or 'sourceSystem'. The parameter names are somewhat self-explanatory, but the description adds no meaning beyond the raw schema, leaving an agent to guess expected value formats and 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 uses a specific verb ('Get') and resource ('DataSource version history'), making the tool's core function clear. It is distinguishable from sibling version tools (e.g., bw_adso_versions, bw_trfn_versions) by the 'DataSource' resource, though it does not explicitly name any sibling or contrast itself.

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

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

No guidance is provided on when to use this tool versus alternatives such as bw_datasource_details or other *versions tools. The intended usage is only implied by the tool name and description, with no explicit context, exclusions, or prerequisite conditions.

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 behavioral burden. It clearly discloses that the current session is dropped, the next call reconnects, and other profiles' sessions remain intact. This gives an agent a solid mental model of side effects.

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

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

Two dense sentences with no filler. The action, scope restriction, and use cases are all front-loaded and each sentence adds meaningful 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 parameterless disconnect tool with no output schema, the description is complete: it states the action, the affected scope, the side effect on the next call, and the intended use cases. Nothing essential is missing.

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

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

The tool takes zero parameters, and the schema fully covers that fact. With no parameters to document, the description appropriately adds no parameter-specific detail, and the baseline 4 applies.

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

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

Description states a specific verb and resource: drop the current environment's BW session/client. It also clarifies scope by noting other profiles' sessions are left intact, which distinguishes it from environment-switching or other session-affecting 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?

Explicitly says when to use the tool: after errors or to force a fresh login. It could also mention when not to use it or explicitly contrast it with a sibling like environment switching, but the context is clear enough.

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

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

With no annotations, the description carries the behavioral burden, and it delivers the key side effects: 'Locks → activates → unlocks' and 'the DTP content is NOT changed.' It does not cover error cases or return behavior, but the core non-destructive activation behavior is clearly disclosed.

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

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

Three concise sentences: purpose, behavioral sequence, and sibling routing. There is no fluff, and the most decision-relevant information is 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?

The description covers purpose, behavior, and when to use the alternative tool, which is sufficient for a one-parameter activation operation. It omits explicit id semantics and output/error details, but those gaps are relatively minor given the tool's simplicity.

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

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

The only parameter, id, has 0% schema description coverage, and the description never explicitly states that id is the DTP's identifier. It is strongly implied by the tool name and 'Activate a DTP,' but the description does not directly add 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 states a specific verb ('Activate') and resource ('DTP'), and immediately distinguishes itself from bw_dtp_save_and_activate by clarifying that content is NOT changed. This makes its role clear even among many DTP-related 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 explicitly names the alternative tool (bw_dtp_save_and_activate) and the exact condition that should trigger that alternative: only when the DTP XML was actually modified. This gives clear when-to-use and 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 carries the full burden for behavioral disclosure. It does disclose the critical fact that the tool is READ-ONLY and does not activate, which is valuable. However, it omits other behavioral details such as return value shape, idempotency, or error conditions, so transparency is only partial.

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 exactly two sentences with no filler. The key safety information (READ-ONLY, does NOT activate) is front-loaded, and the alternative tool is named in a compact clause. Every word earns its place.

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

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

For a single-parameter check tool, the description covers the essential purpose and safety profile, and even suggests the next step (activation). However, with no output schema and no mention of what 'consistency' checks return, an agent may not know what to expect from invoking it. This gap prevents a higher score.

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

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

The schema has 0% description coverage for the only parameter 'id' (type string). The description implicitly suggests that the id identifies the DTP to check, but it never explicitly defines the parameter, its format, or its meaning beyond that inference. Given the low schema coverage, more compensation is required.

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

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

The description states a specific action ('Check') on a specific resource ('DTP consistency') and explicitly contrasts it with activation via a named sibling. It is not a tautology and clearly differentiates the tool from bw_dtp_activate, though 'consistency' could be more concretely defined.

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

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

The description explicitly tells the agent this tool does NOT activate and points to bw_dtp_activate as the alternative for (re)activating. This provides a clear when-not condition. However, it does not describe when to use this over other inspection tools like bw_dtp_details, leaving some usage ambiguity.

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

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

With no annotations, the description carries the full burden. It discloses that the body is minimal and the server hydrates fields, that the created DTP is inactive, and a key limitation about filters (cannot express empty-value comparisons). This is substantial behavioral context, though it does not cover permissions or error behavior.

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

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

Three sentences, each earning its place: the first defines the core action and flow, the second explains the post-creation lifecycle, and the third notes a critical filter encoding limitation. No redundant wording; information is 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?

For a create tool with a rich schema (89% coverage) and no output schema, the description covers the creation flow, the inactive state, and a key filter constraint. It does not describe the return value, but the outputPath parameter in the schema partially addresses response handling. Overall, adequate for an agent to call correctly.

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

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

Schema coverage is high (89%), so the baseline is 3. The description adds value by clarifying that the body is minimal and the server hydrates filter fields, emphasizing that sourceName, targetName, and transformId are the core required parameters. This goes beyond the schema's per-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 the verb 'Create' and resource 'DTP', and specifies the underlying flow ('generic object POST flow (CREA lock + collection POST)'). It is unambiguous and distinct from sibling tools like bw_dtp_check or bw_dtp_execute by focusing on creation.

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

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

Provides a clear workflow: after creation, the DTP is inactive and requires configuration (extractionMode/filter via get_xml → edit → save_and_activate) then activation. This implies when to use this tool (initial creation) versus later configuration tools, though it does not explicitly name alternatives or state 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. It only says the tool returns parsed-and-projected details and to prefer outputPath. It does not disclose whether this is a read-only operation, what the return envelope looks like, how forceCacheUpdate affects behavior, or what happens when outputPath is not used.

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 and front-loaded: the core purpose is stated first, followed by a single actionable usage preference. Every word earns its place and there is 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?

With no output schema and no annotations, the description should explain the return shape and parameter behavior, but it does not. The outputPath schema covers one parameter, but the tool's overall behavior, return format, and relationship to sibling DTP tools remain under-specified.

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 only 33%, with outputPath documented but id and forceCacheUpdate left undescribed. The description adds little parameter meaning beyond 'Prefer outputPath' and does not define what id refers to or what forceCacheUpdate controls, so it fails to compensate for the low 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 states a specific verb and resource: 'Get parsed-and-projected DTP details' and enumerates the content ('fields, filter, program flow extracted from the XML tree'). This clearly distinguishes it from raw-XML sibling tools like bw_dtp_get_xml.

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?

'Prefer outputPath' gives a useful parameter-level usage hint, and the outputPath schema description adds context about when to use it. However, the description does not explain when to choose bw_dtp_details over sibling DTP tools such as bw_dtp_check, bw_dtp_get_xml, or bw_dtp_versions, so the overall usage guidance is only implied.

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 burden of behavioral disclosure. It does explicitly say 'Irreversible action', which is a meaningful warning about side effects. However, it does not disclose whether execution is synchronous, whether it can be repeated safely, what happens to target data, or how results/status are returned.

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

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

The description is concise: two short sentences, front-loaded with the action and a clear warning. There is no filler. It is appropriately brief for a one-parameter tool, though slightly too terse to provide fuller context.

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

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

For a destructive/irreversible execution tool with no annotations and no output schema, the description is thin. It omits return behavior, execution modality, prerequisites, and any indication of what the caller should check afterward. The core action and danger are stated, but an agent is left without enough context to invoke it confidently.

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

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

The single parameter, id, is a bare string with no schema description, giving 0% schema coverage. The description adds no information about what id refers to, its format, or how to obtain it. An agent must infer that id means the DTP identifier.

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

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

The description uses a specific verb, 'Execute', and names the resource, DTP, then clarifies it 'triggers data transfer'. This distinguishes it from the many DTP read/creation/activation siblings. However, it does not explicitly contrast itself with related execution tools like bw_processchain_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 gives no guidance about when to use this tool versus alternatives such as bw_dtp_check, bw_dtp_activate, bw_dtp_save_and_activate, or bw_processchain_execute. It also does not mention prerequisites like whether the DTP must already be active or consistent. The irreversibility warning implies caution but does not help select the right 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?

With no annotations provided, the description carries the full disclosure burden and succeeds. It explains side effects (writing a file under the workdir), response shape differences between outputPath and inline modes, the exact file content semantics for the bw_*_get_xml family versus other get tools, and that pagination/projection is skipped so files contain the complete payload. This is unusually rich behavioral detail.

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 dense and front-loaded with the most important guidance ('ALWAYS prefer outputPath'), and every sentence contributes information. It loses one point because it is a single unbroken paragraph with a long parenthetical about other tools embedded inside the outputPath explanation, which makes it slightly harder to scan.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description covers usage, alternatives, workflow position, file semantics, and response envelopes remarkably well. The only omissions are the meaning of forceCacheUpdate and the exact content of the inline summary envelope, which keeps it from a perfect score.

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

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

Schema coverage is 75%, and the description adds substantial meaning beyond the schema for outputPath (workdir-relative path, raw-XML writing behavior, direct reuse as xmlPath, suitability for large responses, pagination skip) and format (default value, effect on inline responses). The only gap is forceCacheUpdate, which has no schema description and is never mentioned in the tool description — an agent cannot infer what it does.

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 opening sentence states a specific verb ('Get'), a precise resource ('raw DTP XML string'), and the intended purpose ('for PUT updates'). This cleanly separates it from siblings like bw_dtp_details, bw_dtp_get, and the other bw_*_get_xml tools, which are all explicitly differentiated elsewhere in the text.

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, prioritized guidance: 'ALWAYS prefer outputPath', explains exactly when to use inline format='xml' versus format='summary', names the reuse path (xmlPath in bw_dtp_save_and_activate), and contrasts the output with other *_get tools that write JSON rather than raw XML. It even frames the tool as 'Step 1 of read-modify-write', giving workflow context. Nothing is left to inference.

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

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

With no annotations provided, the description carries the full burden and does well: it reveals the lock/PUT/activate/unlock sequence, marks activation as optional, and states that a compact projection is returned unless outputPath is set. It does not explain failure behavior or whether unlock still happens after an error, but this is still substantive disclosure.

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

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

The description is compact and front-loaded with the core pipeline, followed by parameter preferences and return behavior. Every sentence earns its place, though terms like 'PUT' and 'TRKORR' assume domain familiarity.

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 main call path, parameter preferences, transport handling, and return behavior are covered, which is good for a tool with 8 parameters and no output schema. Still, it omits how autoActivate relates to the optional activation, what happens on failure, and when to prefer bw_dtp_activate instead.

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 only 38%, so the description partly compensates by explaining the relationship between xmlPath/xmlContent, transport/createTransport, and outputPath. However, it leaves autoActivate, transportDescription, and id semantics mostly to inference, and it does not explicitly map 'optional activate' to autoActivate.

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 a combined pipeline for saving and activating a DTP object ('lock → PUT → (optional) activate → unlock') and names the preferred input path. It is specific about the resource type via the tool name and sibling context, but it does not explicitly differentiate this tool from bw_dtp_activate or bw_dtp_create.

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 concrete conditional guidance: prefer xmlPath over xmlContent, use transport=<TRKORR> or createTransport=true when a transport is required, and set outputPath for full detail. It lacks an explicit 'when not to use this tool' or a comparison with sibling save/activate tools, but the context is clear enough for most selections.

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. The verb 'Get' implies a read-only operation, but it does not state what the version history contains, whether results are ordered, whether an active connection is required, or any limitations. This is too thin to be considered 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 single sentence is free of fluff and gets straight to the point, but it is under-specified. It is concise in length, not concise in the sense of packing necessary information efficiently, so it earns a middle 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?

For a tool with one required parameter, no output schema, and no annotations, a five-word description is insufficient. The agent is left without parameter semantics, return-value expectations, or behavioral context needed for confident 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 schema only defines 'id' as a required string with 0% description coverage, and the description adds no meaning to this parameter. An agent cannot tell whether 'id' is a DTP technical name, a GUID, or a version-specific identifier, making correct invocation guesswork.

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 ('Get') and a clear resource ('DTP version history'), so an agent can tell this is the version-history lookup for DTP objects. It does not, however, distinguish it from sibling version-history tools like bw_adso_versions or bw_trfn_versions beyond the object type named in the tool name itself.

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

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

There is no guidance on when to use this tool versus alternatives such as bw_dtp_details, bw_dtp_get_xml, or the version tools for other object types. The description gives no context about prerequisites, typical use cases, or when a different tool would be more appropriate.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses 'No network call,' which signals a safe, local read operation, and clarifies it returns profile fields plus the active profile. This is meaningful behavioral context beyond the name and schema.

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

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

The description is two sentences with no waste. It front-loads the primary action, then adds the output fields, safety-relevant no-network-call behavior, and usage guidance. Every sentence earns its place.

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

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

For a zero-parameter, no-output-schema tool with low complexity, the description is complete. It names the returned profile fields, states that no network call is made, and situates the tool before bw_env_switch in the workflow. Nothing essential is missing.

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

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

The tool accepts zero parameters, and the schema description coverage is 100% by default. The description does not need to explain parameters, and it instead provides useful context about what the output contains. This matches the baseline for a parameterless 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 and resource: 'List configured BW environment profiles and which one is active.' It clearly conveys the tool's scope and mentions the output fields. It does not explicitly differentiate itself from bw_system_status, but the action and resource are 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 gives explicit placement guidance: 'Prefer this (or bw_system_status) before bw_env_switch.' This tells the agent when to call it relative to a sibling tool. It lacks a clear 'when not to use' statement or stronger exclusion criteria, 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, the description fully carries behavioral disclosure. It reveals that login is deferred until a client is needed, existing sessions for other profiles are preserved, tool visibility can change based on read-only status, host support varies, and mutating calls are always rejected on read-only profiles.

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

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

Three sentences deliver the purpose up front, followed by dense but relevant behavioral details. There is no filler, and every clause adds information an agent needs before invoking the tool.

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

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

For a one-parameter switch tool with exhaustive schema coverage and no output schema, the description is complete: it covers persistence, timing of authentication, session handling, read-only enforcement, and host compatibility. Nothing essential is missing 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 coverage is 100%, and the schema already explains that 'env' is a profile name from BW_PROFILES with an example. The description only repeats 'test → prod' and adds no new semantic detail 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 states a specific verb ('Switch') and resource ('active BW environment profile'), and immediately clarifies the effect: subsequent tools use the new profile. This makes it clearly distinct from siblings like bw_env_list and bw_disconnect.

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 clear context for when the tool matters: it changes the active profile for all later tools and notes the implications of read-only profiles. It does not explicitly name alternatives or exclusions, but the intended use is unambiguous given the parameter schema's pointer to bw_env_list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Get InfoObject details' and 'Prefer outputPath.' It does not explain return behavior, side effects, permissions, or what happens when outputPath is omitted versus set; the richer outputPath behavior is deferred to the schema rather than the description.

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

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

The description is two short sentences with no filler: the purpose statement is front-loaded and 'Prefer outputPath' is a useful directive. It is concise, though 'Prefer outputPath' is slightly abrupt without immediate rationale.

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 getter with two parameters, the description gives the core purpose and a directive to use outputPath, but it does not describe the response shape when outputPath is not set, what 'metadata' includes, or any caveats. The schema's outputPath documentation fills some gaps, but no output schema exists and annotations are absent, so the description alone is only minimally adequate.

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 50%: outputPath is thoroughly documented in the schema, but the required 'name' parameter has no description. The tool description partially compensates by implying 'name' is the InfoObject identifier, and 'Prefer outputPath' adds invocation guidance, but it does not fully clarify the expected format or meaning of 'name.'

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 names a concrete action and resource: 'Get InfoObject details including metadata.' It clearly identifies the tool as a detail-retrieval operation for an InfoObject, and the resource type distinguishes it from sibling details tools for other object types, though it does not explicitly differentiate from any sibling.

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?

'Prefer outputPath' is a parameter-usage recommendation, not guidance on when to choose this tool over alternatives. There is no mention of when this tool is appropriate compared to sibling validation tools or other get/detail tools, so an agent has no explicit routing 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?

There are no annotations to carry safety or side-effect information, and the description does not say whether the tool returns a boolean, raises an error when the object does not exist, or prints a status message. Without an output schema, the agent is left guessing about the tool's observable behavior beyond the vague verb 'validate'.

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 filler or redundant phrasing. It is appropriately sized for a simple one-parameter validation tool, though its brevity leaves informational gaps that are penalized in other dimensions.

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 is no annotations, no output schema, and no usage guidance, the description is not complete enough for an agent to confidently use the result. For a validation tool, the response or failure behavior is essential context, and that is entirely absent.

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 bare `name` string with no description (0% schema coverage), so the description must compensate. It does clarify that `name` refers to an InfoObject, which is meaningful, but it does not specify naming conventions, expected format, or whether the name is technical or display name.

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 ('validate') and the resource ('an InfoObject'), and the word 'exists' conveys that this is an existence check rather than a retrieval or creation. However, it does not explicitly differentiate itself from siblings like `bw_infoobject_get` or `bw_infoobject_validate_new_name`, so it stops short of full sibling-level 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?

No guidance is given about when to use this tool versus alternatives such as `bw_infoobject_validate_new_name` or `bw_infoobject_get`. The description only states what it does, not when an agent should choose it over related validation or lookup 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 of behavioral disclosure. It states the tool validates name availability but does not disclose what happens on validation failure (e.g., error vs. boolean return), whether it checks case sensitivity, or whether it requires an active connection. The behavior is minimally described but lacks depth.

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

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

The description is a single concise sentence with no wasted words. It is front-loaded with the verb and resource. However, it is so brief that it sacrifices useful detail, though conciseness itself is good.

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 validation tool with one parameter and no output schema, the description is nearly adequate but leaves key gaps: no mention of return value/behavior on invalid names, no naming constraints, and no context on when validation is needed. Sibling tools show a family of validation tools, so more context would help an agent choose correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'name' parameter. The description only says 'a new InfoObject name' is validated, which adds minimal meaning beyond the schema's bare 'name' string. It does not clarify naming rules, length limits, or allowed characters.

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 ('Validate') and resource ('new InfoObject name'), making the tool's purpose clear. It does not explicitly differentiate from sibling tools like bw_adso_validate_new_name or bw_area_validate_new_name, but the resource type (InfoObject) is distinct enough in the 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?

No guidance is provided on when to use this tool versus alternatives like bw_infoobject_validate_exists or other validation tools. The description implies a pre-creation validation use case but does not state it explicitly or mention any exclusions.

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

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

With no annotations, the description must disclose behavior itself. It explicitly states 'Irreversible', which is a critical destructive trait. It also hints at a locking requirement for InfoArea. However, it doesn't describe the operation's side effects (e.g., whether dependent objects are cascaded), return values, or required permissions. The irreversibility disclosure is valuable, but other behavioral aspects are left implicit.

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

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

Two sentences with no filler. The core purpose and irreversibility are front-loaded, followed by a precise parameter rule. Every word earns its place, and the structure is easy 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?

Given it's a destructive tool with no output schema, the description covers the essential aspects: what it does, that it's irreversible, and the type-specific parameter requirements. It doesn't explain error handling or confirmation, but for a delete operation with this level of simplicity, it's fairly complete. A slight gap is the lack of guidance on what happens on success (e.g., return value), but that's minor 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?

The schema already describes objectType and lockHandleOrTransport, but objectName has no description. The description adds the crucial distinction: lock handle for InfoArea, transport request for others, which is not evident from the schema alone. This compensates for the 67% coverage by clarifying the conditional parameter 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 'Delete any BW object' – a specific verb and resource – and adds the critical 'Irreversible' warning. It also specifies the type-dependent parameter handling (lock handle vs transport request), which distinguishes it from the sibling bw_area_delete that targets only InfoAreas.

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 parameter-specific instructions for InfoArea vs other types but does not explicitly state when to prefer this generic tool over the sibling bw_area_delete. It implies this is the catch-all delete tool, but doesn't mention the alternative or conditions for choosing it. Some guidance is present (lock handle vs transport), but no when-to-use vs 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?

There are no annotations, so the description must carry the behavioral burden. 'Check' implies a read-only validation, but the description does not say whether it mutates anything, what 'consistency' means, whether it performs a remote call, or what happens if the chain is inconsistent. This is a meaningful transparency gap.

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

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

The description is a single efficient sentence with no wasted words, but it is under-specified rather than appropriately concise. It front-loads the core operation but lacks the details expected for a tool with no annotations or output schema.

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?

With no output schema and no annotations, the agent has no idea what the tool returns (boolean, issue list, status) or what constitutes a failed check. It also lacks prerequisites and side-effect information, leaving the context incomplete 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?

Schema coverage is 0% and the description never mentions the required id parameter. The parameter name is inferable from the tool name, but the description adds no format guidance, source for the ID, or meaning beyond the bare schema 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 uses a clear verb-resource pair: 'Check' + 'process chain consistency', so an agent can tell this is a validation/check operation rather than an execution or detail fetch. However, 'consistency' is not defined and there is no explicit contrast with sibling tools like bw_processchain_details, so the differentiation is only partial.

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 call this tool versus alternatives such as bw_processchain_execute, bw_processchain_logs, or the other *_check tools. An agent cannot infer prerequisites (e.g., process chain must exist, connection required) or whether this should precede execution.

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 behavioral burden, but it only says the result is 'parsed' and advises using outputPath. It does not describe the default return shape, side effects, size implications, or what happens when outputPath is omitted. 'Prefer outputPath' hints at large responses but does not actually disclose the behavior.

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

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

The description is two short sentences with the core action placed first and no filler. 'Prefer outputPath' is concise, although its terseness means the agent must rely on the schema for full 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?

There is no output schema and no annotations, yet the description does not explain the default return format or when this tool should be chosen over related process-chain tools. The rich outputPath parameter documentation helps, but the tool-level context remains incomplete for an agent deciding how to invoke it.

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

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

The outputPath parameter is already documented extensively in the schema, and the description adds only a terse preference for it. The required id parameter lacks a description, but it is self-evident as a resource identifier. The description adds marginal meaning beyond the schema but does not fully compensate for the undocumented id parameter.

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 ('Get') and the resource ('parsed process chain details'), and narrows the result to 'steps'. This goes well beyond the bare tool name and gives an agent a clear sense of what the tool returns, though it does not explicitly differentiate from sibling process-chain 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 guidance is provided about when to use this tool versus siblings like bw_processchain_logs, bw_processchain_check, or bw_processchain_execute. 'Prefer outputPath' is a parameter preference, not tool-selection guidance, and no exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden and does disclose one important trait: the action is irreversible. However, it omits other behavior, such as whether execution is synchronous, what exactly gets triggered, what side effects occur, or what is returned on success or failure.

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 only two short sentences with no filler. The action is immediately stated, and the important irreversible warning is included, which is appropriately concise for a one-parameter execution tool.

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

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

For a mutating execution tool with no annotations and no output schema, more context would help, such as confirmation behavior or follow-up actions like checking bw_processchain_logs. The core purpose and irreversible nature are covered, so it is minimally adequate but not complete.

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

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

Schema description coverage is 0%, and the description never explains that 'id' refers to the process chain identifier or whether any format is expected. The schema only says 'id' is a required string, so the description adds no semantic value beyond what the tool name itself suggests.

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 names a specific action ('Execute') and resource ('process chain'), and the irreversible warning distinguishes it from inspection tools like bw_processchain_details, bw_processchain_check, and bw_processchain_stop. Even without opening the schema, an agent knows this tool triggers a process chain rather than inspecting or stopping it.

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

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

The intended use is implied by the verb, but there is no explicit guidance on when to choose this over sibling tools such as bw_processchain_check, bw_processchain_details, or bw_processchain_stop. It also does not state prerequisites, such as the chain needing to already exist, 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It does well by revealing default behavior, paging behavior, the outputPath full-payload behavior, and the response envelope. It does not mention error or auth behavior, but for a read-oriented log tool this is a minor gap.

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

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

The description is two tight sentences with no filler. The first sentence states purpose and default behavior; the second covers paging and outputPath. Every sentence earns its place.

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

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

For a log retrieval tool with no annotations and no output schema, the description supplies essential context: response shape, default recency, paging, and the full-output alternative. It could explicitly say that id identifies the process chain, but the tool name and sibling context make that low-risk. Overall, it is sufficiently complete 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 50%: limit and outputPath have schema descriptions, while id and offset do not. The tool description partially compensates by framing limit/offset as paging and outputPath as the full log set, but id is still left to inference. The lengthy outputPath schema text carries most of that parameter's meaning, so the description adds grouping rather than complete definitions.

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 opens with a specific verb and resource: 'Get process chain execution logs and current run status.' This clearly distinguishes it from sibling tools like bw_processchain_execute, bw_processchain_stop, or bw_processchain_details, and it names an expected response shape. It is non-tautological and immediately actionable.

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 practical usage guidance: it defaults to the most recent log entries, supports limit/offset paging, and offers outputPath for the full log set. It does not explicitly compare against sibling tools, but the intended contexts are clear enough for selection and invocation.

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 warns that the action is irreversible, which is essential for a stop operation, but it does not describe side effects on running jobs, logs, or subsequent scheduling.

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: two short sentences, no filler, and the key scoping and risk information is front-loaded. 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?

The tool is structurally simple with one string parameter and no output schema, so the description does not need to explain much. Still, the id semantics are undocumented and there is no mention of return or failure behavior, making it adequate but not fully self-contained.

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 never mentions the 'id' parameter. The tool name and context let an agent infer that id likely identifies the process chain to stop, but the format, whether it is a run instance id, and any constraints remain 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 names a specific verb ('Stop') and a specific resource ('running process chain'), and it is the only stop-oriented tool among the siblings. It is clearly distinguishable from bw_processchain_execute, bw_processchain_check, and bw_processchain_logs.

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

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

The phrase 'running process chain' implies that the tool is for active executions and provides some contextual guidance. However, there are no explicit when-not-to-use conditions, no alternatives are named, and there is no guidance on how the chain should be identified before stopping.

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 one-sentence description carries the full burden of behavioral disclosure. 'Pre-check' suggests a read-only validation, but the description does not state whether it mutates anything, what conditions it verifies, what it returns, or what side effects (if any) it has.

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

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

The description is a single focused sentence with no filler or repetition tangent. It is front-loaded and to the point, though it sacrifices substantive detail for brevity.

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?

With no output schema, no annotations, and only a minimal description, there is not enough context for an agent to know what the pre-check returns, how to interpret success or failure, or what prerequisites must exist. The tool is simple, but the description still lacks important behavioral and output 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 only 33% and the description does not compensate. The required parameters 'sourceSystem' and 'datasource' are self-explanatory by name, but the description adds no additional meaning about their format, allowed values, or relationship to each other beyond identifying the DataSource itself.

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, 'Replication pre-check for a DataSource,' identifies the operation ('pre-check') and the resource ('DataSource') clearly, and it is more specific than the tool name alone. It is not a tautology, but it does not explicitly differentiate itself from siblings like bw_replication_replicate or bw_replication_replicate_full.

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 word 'pre-check' implies the tool should be used before performing replication, but the description never states this explicitly or names any alternative. There is no 'use when' or 'instead of' guidance, leaving the agent to infer the intended workflow.

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 says 'Trigger DataSource replication' and clarifies the activate type, but says nothing about side effects, permissions, reversibility, or what happens on failure. This is a significant gap for a replication-triggering 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 fluff. It front-loads the main purpose and adds one parameter clarification. It is appropriately concise, though it sacrifices content for brevity.

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 6 parameters, 3 required, and no annotations, the description is severely incomplete. It doesn't explain the tasks array structure, the meaning of activate strategies, or how this tool relates to bw_replication_replicate_full. The outputPath behavior is documented in the schema but not in the description, and the description leaves too much for the agent to infer.

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 50%, so the description should compensate for undocumented parameters like sourceSystem, datasource, and background, but it does not. The one clarification about activate ('strategy string, not boolean') adds a little value, but it's redundant with the schema's type and doesn't explain how to choose values. The description fails to compensate for 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 action (Trigger DataSource replication) and adds a distinguishing detail (with explicit pre-check tasks). It does not explicitly name the sibling bw_replication_replicate_full, so it could be sharper, but the core purpose is clear.

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 like bw_replication_replicate_full. The only hint is the mention of 'explicit pre-check tasks,' but it doesn't explicitly state when that matters or when to choose the other tool. No exclusions or prerequisites 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the tool performs a pre-check and then triggers replication, which implies a mutating/executing action, but it does not explain side effects, whether the trigger runs synchronously, what the pre-check actually validates, or what happens on check failure.

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

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

The description is extremely short and front-loads the core workflow with a clear arrow notation. There is no wasted text. Its brevity is an asset structurally, though it sacrifices substance in other dimensions.

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 5 parameters, no annotations, and no output schema, the description is insufficient for correct invocation. It explains neither the meaning of the optional parameters nor what 'pre-check' entails, leaving an agent to guess at required semantics and post-trigger expectations.

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 only 20% (only outputPath is documented), and the tool description provides no parameter explanations at all. sourceSystem, datasource, activate, and background are left entirely to inference, so the description fails to compensate for the low 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 states a clear purpose: perform a pre-check and then trigger replication. It is specific about the workflow and differentiates itself as a 'one-stop' combined operation, which separates it from the sibling bw_replication_replicate that likely only triggers. However, it does not name that sibling explicitly.

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

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

The phrase 'One-stop: pre-check → trigger replication' implies when to use this tool: when the user wants both validation and execution in a single call rather than separate steps. However, it gives no explicit when-not-to-use guidance and does not identify alternatives such as bw_replication_info or bw_replication_replicate.

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 itself indicates a read-only GET operation, lists what it returns, and warns that payloads are large. It does not discuss permissions or failure behavior, but the key behavioral trait (large response) and the mitigation (outputPath) are present.

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

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

Three sentences, front-loaded with the core purpose, followed by two high-value usage notes. No filler or redundant restatement.

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 parameter schema covers all fields and the description covers purpose, return content, payload size, and the main alternative, the tool is callable without missing essential context. Without annotations or an output schema, slightly more detail about expected result size/pagination could be added, but it is not critical.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description adds only contextual value about outputPath and provider prefixes, not a meaningful amount of new parameter semantics beyond the schema.

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

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

States a specific verb (GET), resource (BICS initial reporting view), supported provider types (ADSO / InfoObject / Composite Provider), and the returned content (metadata, default axes, result set). It explicitly names bw_reporting_preview as the tool for axis remapping, making the distinction clear.

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?

Gives direct usage guidance: prefer outputPath because payloads are large, and use bw_reporting_preview instead when axis remapping is needed. This tells an agent when to choose this tool and when to route elsewhere.

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 discloses the multi-step behavior (GET metadata → POST refresh), the inline response format (flatRows, paginated), and the outputPath behavior (full result written, small summary envelope returned, skip inline pagination). It also explains the file format nuance for XML vs parsed JSON. This is substantial behavioral disclosure beyond the schema.

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 dense but well-structured: the core workflow is front-loaded in the first sentence, followed by response format and outputPath guidance. The outputPath paragraph is long and covers multiple nuances (JSON vs XML, other *_get tools, large responses), which is valuable but slightly verbose. Every sentence earns its place, though the outputPath explanation could be tightened.

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 6-parameter tool with no output schema and no annotations, the description covers the essential workflow, response format, pagination, and outputPath behavior. It doesn't explicitly describe the default row limit or the exact shape of the inline response beyond 'flatRows (paginated)', but the schema documents fromRow/toRow defaults. The description is complete enough for an agent to call the tool correctly, with minor gaps around error cases and the exact summary envelope fields.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the overall flow (rows/columns placement, refresh) and by clarifying the outputPath behavior (summary envelope, file format, skip pagination). It doesn't add per-parameter syntax details beyond the schema, but the schema already covers those. The added context about outputPath and flatRows justifies a 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 states a specific verb ('preview'), the resource (BICS query), and the workflow (GET metadata → put characteristics on ROWS/COLUMNS → POST refresh). It also names the analogous Eclipse Dashboard Preview and distinguishes it from the sibling bw_reporting_initial_view / bw_reporting_update_view by describing the convenience flow. This is a clear, specific purpose.

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 explains the intended usage pattern (convenience preview, same as Eclipse Dashboard Preview) and gives a clear when-to-use signal for outputPath ('Use outputPath for large responses'). It does not explicitly say when NOT to use this tool versus bw_reporting_initial_view or bw_reporting_update_view, but the workflow description implies it is the preview variant. Slight gap in explicit 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?

There are no annotations, so the description carries the behavioral burden. It does disclose a key behavioral requirement (full state expected, not partial axes) and implies mutation through 'POST' and 'refresh', but it does not disclose side effects, persistence, permissions, or default return behavior.

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

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

Two tight sentences with no filler. The core behavior is front-loaded and the sibling routing guidance is delivered economically.

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 five parameters and full schema coverage, the description plus schema is largely sufficient. The missing piece is a clear statement of the default return value without outputPath, although the outputPath parameter description partly compensates.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds important semantic context beyond the schema by specifying that the state array must contain the full infoObject state from bw_reporting_initial_view, which clarifies what 'full selection state' means in practice.

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 ('POST updated BICS axes and refresh the result set') and the resource, and it explicitly distinguishes itself from bw_reporting_preview. The instruction to pass the full state from bw_reporting_initial_view further clarifies its role in the reporting workflow.

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 concrete usage guidance: pass the full infoObject state from bw_reporting_initial_view, and prefer bw_reporting_preview only for row/column characteristic names. This is explicit when-to-use vs alternative routing.

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 'search' and 'Returns a list' imply a read-only operation, and the outputPath note signals writing behavior for large results. However, it does not explicitly state non-mutation, default pagination/limits, or what happens if the result set is large without outputPath.

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 three short sentences with the core purpose, return shape, and key usage tip front-loaded. Every sentence contributes information, and there is no redundant restatement of the tool name or schema.

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?

With no annotations and no output schema, the description covers the essential invocation path: required searchTerm, filters, result shape, and outputPath for large sets. It leaves gaps around default result-size behavior, how multiple filters combine, and an explicit read-only guarantee, which an agent may need to call the tool confidently.

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

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

The schema already documents most parameters: searchTerm wildcards, ISO date fields, objectType enum, and a detailed outputPath description. The description adds a high-level grouping of filters (type, dates, name/description), which helps orient an agent but does not add significant per-parameter semantics 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 identifies the tool as an 'Advanced BW object search' with named filters (type, dates, name/description), and gives a concrete return shape of object metadata fields. This is specific enough to distinguish it from the many sibling detail/retrieval tools, none of which are object-search tools.

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

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

The use case is implied: find BW objects by search term with optional filters. The only explicit guidance is 'Use outputPath for large result sets,' which addresses response-size handling rather than when to choose this tool over an alternative. No sibling alternatives or exclusion conditions 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, the description carries more behavioral responsibility and does disclose a real side effect: auto-login on first call. However, it does not state whether the operation is strictly read-only, what permissions are involved, or what happens on repeated calls, so transparency is only partial.

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 short and front-loaded, moving from purpose to usage notes in three sentences. The second sentence partially repeats the outputPath parameter description and 'separate tools' is vague, but the text remains economical and readable.

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 one optional parameter, no output schema, and no annotations, the description covers auto-login, use of outputPath, and how to read a single property. It does not describe the default return payload or distinguish the tool from bw_system_status, so an agent may still be uncertain about exact output and tool selection.

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

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

Schema coverage is 100% and the only parameter (outputPath) is already fully described in the schema. The main description adds only a brief recommendation to use outputPath for full documents, providing no new parameter-level meaning beyond the baseline.

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

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

The description identifies a specific verb ('Query') and resource ('BW system info and capabilities') scoped to 'the current environment', so the tool's purpose is clear. It does not explicitly contrast sibling bw_system_status, leaving some differentiation to inference from the 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 gives clear practical guidance: use outputPath for the full document and read the returned document for single property/capability checks rather than separate tools. It lacks a named alternative or explicit when-not-to-use conditions, but the provided context is actionable.

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 and discloses an important behavioral trait: 'No network call.' It also clarifies that it reports whether a live BW session exists and the workdir for file buffering, which helps an agent understand what to expect beyond a bare status label.

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

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

The description is compact and front-loaded: it states the core action first, then lists the returned information, and closes with the primary use case. No redundant filler or restatement of the tool name.

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, read-only status tool, the description covers the main things an agent needs: what the tool reports, that it makes no network call, and when to use it. It does not describe error conditions or how to interpret the 'live BW session' flag, but these are minor for this simple status 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?

The tool has zero parameters, so the schema is trivially complete. The description adds value by detailing what the output will contain (profile fields, session status, configured profiles, workdir), which is more useful than schema information alone for a parameterless 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 ('Report') with a clear resource ('MCP server status') and enumerates the exact contents: environment profile fields, live session status, configured profiles, and workdir. It is unambiguous about what the tool returns, though it does not explicitly differentiate itself from the similarly named sibling bw_system_info.

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 guidance: 'Use this first to confirm the server is wired to the right BW system.' This clearly states when to invoke the tool, but it does not mention alternatives or exclusions, especially relative to bw_system_info.

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 carries the full burden. It discloses that the call merges several metadata aspects and that outputPath produces a full snapshot with a summary envelope. However, it does not describe the default inline return shape or whether the default response is paginated/truncated, which is relevant given the outputPath 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 tool description is two crisp sentences that front-load the purpose and then give the key usage tip. Every sentence earns its place, and the longer outputPath detail is appropriately placed in the schema rather than the main description.

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 two-parameter tool with no output schema, the description is largely complete: it states what the tool returns conceptually and gives a strategy for obtaining the full snapshot. The main gap is the missing default response format, but the agent can still invoke the tool correctly with just the required table parameter.

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 input schema already documents both parameters fully. The main description adds little beyond the schema; even the rich outputPath explanation lives inside the schema property description. This matches the baseline 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 names a specific verb and resource: 'Describe a DDIC table in one call'. It also enumerates the exact scope of the result—metadata, info, fields, and data-preview metadata—which separates it from data-retrieval siblings like bw_table_get_data or bw_table_query_sql.

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 clear context: use this tool to describe a DDIC table, and 'Prefer outputPath when you need the full snapshot' is a concrete conditional usage guideline. It does not explicitly name alternatives or exclusions, but the guidance is sufficient for correct 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?

No annotations are present, so the description carries the behavioral disclosure burden. It discloses the ADT data-preview backend, the maxRows cap motivation, and the outputPath escape hatch for large payloads. It does not mention response format or auth requirements, but the main read-only behavior and payload limits are clearly surfaced.

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 compact sentences with no filler. It front-loads the core purpose and then adds the most important behavioral caveat. Every clause 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?

The rich parameter schema covers all six parameters, but there is no output schema and the description does not specify the inline response format when outputPath is not used. The outputPath parameter description clarifies the file-writing summary envelope, but the default return payload shape is left implicit.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a little context by explaining that maxRows defaults small and outputPath is intended for large reads, but these details also appear in the schema. It does not significantly deepen parameter understanding for table, columns, orderBy, or whereClause 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 identifies a specific operation: querying DDIC table data via the ADT data-preview service using OpenSQL SELECT. It clearly names the resource and the action. However, it does not explicitly differentiate itself from the sibling bw_table_query_sql, which could be a near alternative.

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

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

The description gives practical guidance about maxRows default/cap and recommends outputPath for large reads. It does not mention when to prefer this tool over siblings like bw_table_describe or bw_table_query_sql, so exclusions and alternative routing are missing.

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