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 lifecycle prerequisite (class must already exist/be modified) but says nothing about side effects, idempotency, lock/permission needs, or what activation failure looks like — real gaps for a state-changing 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?

Two tight sentences with the core action front-loaded and the parameter routing immediately after. 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?

With no annotations and no output schema, the description should say more about the result of activation (success/failure signal, whether it returns diagnostics). It covers the invocation contract adequately but leaves the outcome 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 description coverage is 100%, so the schema already documents all three parameters, including the class_name/class_names exclusivity that the description merely repeats. The description adds no meaning for preaudit_requested beyond what the schema states.

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 (Activate) and resource (ABAP classes) and scopes it to a lifecycle stage ('after creation or modification'), which distinguishes it from CreateClass/DeleteLocalClass. It does not explicitly name the sibling it complements, but the action is unambiguous.

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

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

Gives clear context for when to invoke it (post-creation or post-modification) and states the mutually exclusive parameter pattern ('either class_name ... or class_names'). It stops short of naming alternatives or prerequisites such as needing an existing class first.

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

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

With no annotations, the description must carry the burden. It does disclose the return behavior (detailed error information) and the three input modes, which is useful. However, it never states that this is a non-mutating check with no side effects on the ABAP system, nor any auth or timeout constraints.

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

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

Two sentences, front-loaded with purpose followed by the mode/priority rule. Every clause carries information 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?

For a 4-parameter tool with no annotations and no output schema, the description covers purpose, input modes, and output type. It leaves the safety profile (read-only, no activation) and validation failure behavior unspecified, which the absent annotations leave 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 100%, so each parameter is already documented with its own guidance, including the same precedence rules the description restates. The description adds no syntax, format, or example detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: 'Check ABAP source code syntax and return detailed error information.' That is clearly distinct from siblings like RunATC (ATC check runs) or GetProgram (retrieval). It stops short of naming a sibling explicitly, but the resource/verb pairing is unambiguous.

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

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

It explains the three input modes and their precedence, which guides invocation, but it never says when to prefer this tool over RunATC or a source-fetch tool, nor any prerequisites. Usage is implied by the input-mode rules rather than stated as a selection criterion.

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 disclosure burden and does well here, naming the three output modes and characterizing each (summary = 'statistics only'). It stops short of stating that this is a non-mutating read operation or any system/permission prerequisites, which is the only meaningful gap for a no-annotation 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?

Two sentences, front-loaded with the core action and then the supporting workflow. No filler; every clause carries routing or output-format 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?

No output schema exists, so the description must (and does) characterize the return value as a formatted diff with three selectable formats. It is nearly complete for a comparison tool, though it could note that summary mode returns no line-level detail, which affects downstream parsing 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 coverage is 100%, so the schema already documents all six parameters including the format enum and version ID syntax. The description echoes the format options and adds version-ID provenance (traceable to GetVersionHistory) but adds little beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: 'Compare two versions of an ABAP object and return a formatted diff.' This is clearly distinguishable from siblings like GetVersionHistory (retrieval) and GetProgram (single-version fetch), so an agent can route correctly 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?

Explicitly names the alternative workflow: 'Use with GetVersionHistory or GetTransportVersions to identify version IDs, then compare them to see exactly what changed.' It tells the agent both the prerequisite tools and the goal state that selects this tool, leaving nothing to inference.

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

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

With no annotations, the description carries the full burden. It usefully discloses upsert semantics ('create or replace') and default activation behavior, but omits prerequisites (auth/transport needs), what happens if a BDEF already exists, and failure modes for non-local packages.

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 short sentences, front-loaded with the core action and followed by the two most decision-relevant constraints (package restriction, default activation). No filler, though the type enumeration mildly duplicates the schema enum.

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 7-parameter mutation tool with no annotations and no output schema, the description covers scope, constraints, and activation but leaves out permission/transport prerequisites and result behavior. Adequate but with clear gaps an agent would want filled.

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

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

Schema description coverage is 100%, so all 7 parameters are already documented by the schema (defaults, enums, naming rule for behavior_name). The description only reinforces the type list and package constraint, adding little beyond the structured fields. Baseline 3 applies.

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

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

States a specific verb+resource: create/replace a RAP Behavior Definition (BDEF) in SAP. This is clearly distinguishable from read-side siblings like GetBehaviorDefinition and ExportBehaviorDefinitionToFile. An agent can tell what artifact is produced without opening the schema.

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 real constraints ('Only supports local packages ($TMP, $LOCAL, $-prefixed)') and the supported BDEF kinds, which implies when it can be used. However, it never names an alternative or states when to prefer another tool over this one, so routing 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?

With no annotations, the description carries the full burden and does disclose useful traits: it is a mutation tool that can replace an existing view, it is restricted to local packages, and it auto-activates by default. It stops short of stating authentication/prerequisite requirements (e.g. prior login) or the failure mode when the view already exists in a transportable package.

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 short front-loaded sentences with no filler; the core purpose and constraints come first. The final sentence restates the schema's auto_activate default, which is slight redundancy but harmless.

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

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

For a mutation tool with no annotations and no output schema, the description covers scope and activation behavior but omits prerequisites (session/login), whether activation results are returned, and what happens on syntax or package errors. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so defaults, the Z/Y naming rule, and the auto_activate/preaudit_requested relationship are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a precise verb pair (create or replace) plus a specific resource (local CDS DDL view) and scope (local packages only). This clearly distinguishes it from siblings like CreateClass, CreateBehaviorDefinition, and CreateServiceDefinition, which target different artifacts.

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?

"Only supports local packages ($TMP, $LOCAL, $-prefixed)" is a real precondition that tells the agent when the tool will work, but there is no guidance on alternatives (e.g. using GetCDSView to inspect an existing view first, or routing non-local packages elsewhere) and no explicit when-not 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?

With no annotations, the description carries the full disclosure burden, but it does contribute one real behavioral fact: the class is created without a transport assignment (i.e., a non-transportable local object). It omits other behavior an agent would want for a mutation tool – required authorization, error/rollback behavior, whether the class is left inactive by default, and what is returned – leaving it only partly transparent.

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

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

A single front-loaded sentence with zero filler; the resource comes first and the two constraining qualifiers follow immediately. Nothing could be trimmed without losing 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 6-parameter write tool with no annotations and no output schema, the definition is thin: it leaves unclear what the tool returns (class object, activation status, errors), how auto_activate/preaudit_requested interact with creation, and how the result relates to the CreateClassImplementation/CreateClassTests siblings. The schema covers the inputs, but the description adds nothing about outcome or lifecycle.

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

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

Schema description coverage is 100%, so every parameter (package default, Z/Y name rule, source_code contents, auto_activate, preaudit_requested) is already documented in the schema. The description only echoes the $TMP default and adds no new parameter-level detail, so the baseline 3 applies.

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

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

States a specific verb+resource (create an ABAP class) with two qualifying constraints: it lands in a local package ($TMP) and carries no transport assignment. That scope clearly separates it from ImportClassFromFile, CreateClassImplementation, and the various Get*/Export* siblings, though it never names an alternative 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?

There is no when-to-use guidance at all: nothing says when to prefer this over CreateClassImplementation, CreateClassTests, or ImportClassFromFile, and no prerequisite (class must not already exist, must be inactive, etc.) is stated. The only usage signal is the implicit $TMP restriction baked into the description.

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

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

No annotations exist, so the description carries the full behavioral burden. 'Write or replace' hints at destructive overwrite of existing implementations, but nothing is said about activation side effects (auto_activate defaults true), pre-audit behavior, required authorizations, or what happens to existing code not present in the new source. This is thin for a mutation 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?

Two short sentences with the key operation front-loaded. The second sentence largely restates the scope of the first ('method implementations' vs 'CCIMP'), so it is efficient but not entirely waste-free.

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

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

A mutation tool with no annotations and no output schema should explain return/error behavior and the activation implications of the defaulted boolean flags. The description covers what is being written but leaves the agent to infer failure modes and overwrite semantics from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including their defaults. The description adds no syntax, format, or sizing guidance beyond the schema (e.g. whether source_code must be complete or may be partial), so baseline 3 applies.

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

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

Names a specific verb+resource: writing/replacing the CCIMP include of an existing global ABAP class. The phrase 'local class implementations (CCIMP)' and 'existing global ABAP class' distinguishes it from siblings like CreateClass and DeleteLocalClass, so an agent can route correctly.

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

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

The second sentence gives implied context ('use this to update method implementations for local classes'), which scopes it to the local-implementation case. However, it names no explicit alternatives (e.g. CreateClass, DeleteLocalClass, CreateClassTests) and states no when-not 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 full behavioral burden. It states 'create or replace' but doesn't disclose what happens to existing test classes (overwrite), whether backups are needed, activation side effects, or permission requirements. The schema parameters hint at these, but the description adds no behavioral context beyond the verb.

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

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

A single, front-loaded sentence that states the action and target. No wasted words.

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

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

For a mutation tool with no annotations and no output schema, the description is thin. It omits key context like the replace/overwrite behavior, activation implications, and how it relates to sibling tools. The rich schema covers parameters, but the description doesn't compensate for the lack of behavioral guidance.

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

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

Schema description coverage is 100%, so all five parameters are documented in the schema with defaults and meanings. The description adds no parameter details, which is acceptable given the high 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?

States a specific verb+resource: 'Create or replace test classes within an existing global ABAP class'. The 'or replace' behavior is useful clarity. It doesn't explicitly differentiate from siblings like CreateClass or GetClassTests, but the resource (test classes) is narrow enough to be understandable.

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

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

No guidance on when to use this versus alternatives like CreateClass, RunClassTests, or GetClassTests. The description doesn't mention prerequisites such as the parent class already existing, even though the schema notes it. An agent gets no routing help.

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 two real behaviors: an existing definition is replaced (destructive overwrite) and activation happens automatically by default. However, it omits auth/authorization requirements, what happens if activation fails, and whether a failed activation leaves the object inactive or rolls back.

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 short sentences, each carrying distinct information (what it creates, the package restriction, the activation default), with the core purpose front-loaded. No filler or redundancy.

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?

Parameters are fully documented by the schema, but this is an unannotated create/replace mutation with no output schema, so the description should say something about the result (success indicator, activation outcome). The package constraint is covered; the response and failure behavior are not.

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 six parameters and the baseline is 3. The description reinforces the local-package constraint on 'package' and the auto-activation default, but adds no syntax, format, or validation detail beyond the schema text.

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

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

The description gives a specific verb pair ('Create or replace') plus a precise resource ('Service Definition (SRVD)') that cleanly separates it from the CreateCDSView, CreateClass, and CreateBehaviorDefinition siblings. The 'or replace' wording also telegraphs the tool's overwrite semantics rather than just naming an operation.

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

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

It states one hard precondition (only local packages, $TMP/$LOCAL/$-prefixed) which meaningfully narrows when the tool is usable, but there is no guidance on when to choose this versus the read counterpart GetServiceDefinition or versus transport-based flows for non-local packages. Usage is implied rather than spelled out.

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 bears the full burden of behavioral disclosure. It says the tool deletes a class, but it does not state whether deletion is irreversible, what permissions are required, or what happens to dependent objects; that is a significant gap for a destructive operation.

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

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

The description is a single front-loaded sentence with no filler. It conveys the action and the key scope restriction efficiently for a one-parameter 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 simple one-parameter delete tool with complete schema coverage, the core action and scope are adequately covered. However, with no annotations and no output schema, the description should at least mention irreversibility or authorization requirements, and its omission leaves a meaningful behavioral gap.

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

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

Schema description coverage is 100%, and the single class_name parameter is fully documented in the schema, including the Z/Y prefix requirement. The description's parenthetical reinforces that constraint but adds no new syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: delete a local ABAP class. It also narrows the scope to Z/Y classes in local packages, which helps distinguish it from broader class operations like CreateClass or GetClass.

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 parenthetical restriction to Z/Y classes in local packages is a usage constraint, but the description never names alternatives or states when not to use this tool. The guidance is therefore 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 carry the full behavioral disclosure. It does state important traits: writing to a specific tmp folder, using a .dcls.asdcls extension, and automatically converting the DCL name to Z-namespace. However, it omits whether existing files are overwritten, what permissions are required, what the return value is, and 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?

The description is two concise sentences that front-load the main action and output destination. Every sentence provides useful information without redundancy or filler. It is appropriately sized for the tool's simplicity.

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 simple schema and no output schema, the description covers the core action and output file details. However, it does not state what the tool returns (e.g., file path or success indicator) or address potential side effects like overwriting. For a file-export tool, this leaves a moderate gap in contextual completeness.

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

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

Schema description coverage is 100%, so the schema already documents the single dcl_name parameter. The description adds meaningful context beyond the schema by noting that the DCL name is automatically converted to Z-namespace, which affects how the input name is interpreted. This additional semantic detail justifies a score above the baseline 3.

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

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

The description states a specific verb (Export), resource (CDS access control (DCL)), and output destination (file in tmp folder with .dcls.asdcls extension). It clearly distinguishes from sibling export tools like ExportCDSViewToFile or ExportClassToFile by naming the exact object type. An agent can identify the tool's action without opening the schema.

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 indication of when to use this tool versus alternatives such as GetAccessControl or other export tools. It lacks any prerequisites, conditions, or exclusions. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses non-obvious behavior: the output location (tmp folder), the .bdef.asbdef extension, and the automatic Z-namespace conversion of the behavior name. However it omits overwrite behavior for an existing file and what the call returns (e.g., a path), which matter for a write-to-disk 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?

Two short sentences with no filler, and the core action plus destination are front-loaded before the namespace-conversion detail.

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

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

With no output schema and no annotations, the description should carry more of the contract. It covers destination and naming behavior but leaves the return value (file path?) and overwrite semantics unexplained, which are the details an agent needs to chain this 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?

One required parameter with 100% schema description coverage, so the schema already documents behavior_name and the baseline is 3. The description adds marginal value by noting the name is converted to Z-namespace, but gives no further syntax or format 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?

States a specific verb (export) and resource (RAP behavior definition) plus the destination (file in tmp with .bdef.asbdef). It implicitly contrasts with the sibling GetBehaviorDefinition by emphasizing file output, but never names that alternative explicitly, so differentiation is left to inference.

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

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

Usage is implied by the 'to file' framing versus retrieval siblings, but there is no explicit statement of when to choose this tool over GetBehaviorDefinition or the other Export*ToFile variants, nor any prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral burden and it partially discharges it by disclosing the output location, the fixed file extension, and a non-obvious side effect (automatic Z-namespace conversion of view name and SQL view name). It omits other relevant traits: whether an existing file is overwritten, what is returned to the caller, and any permission/authorization prerequisites.

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

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

Two sentences, no filler. The primary action and destination are front-loaded, and the second sentence carries genuinely useful information about the namespace transformation rather than restating the 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 one-parameter file-writing tool with no annotations and no output schema, the description covers the essentials (what is exported, where it lands, how it is named). It stops short of the details an agent would want before invoking a write-to-disk operation: overwrite behavior, return value, and error/authorization conditions.

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

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

Schema description coverage is 100% and there is only one parameter, whose schema entry already documents the name and gives examples (I_Material, C_SalesOrder). The description adds no syntax, format, or naming details for view_name beyond what the schema states, so the baseline 3 applies.

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

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

States a specific verb (Export), a specific resource (CDS DDL view), and a specific destination (a file in the tmp folder with .ddls.asddls extension). This cleanly distinguishes it from the sibling read tools GetCDSView/GetCDSViewContents and from the other Export*ToFile tools that target different object types.

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 'directly to a file in the tmp folder' implies the use case (persisting a view to disk rather than retrieving content inline), which is enough to infer usage against GetCDSViewContents. However, it never names an alternative or states an explicit when/when-not condition, so guidance remains implicit rather than stated.

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

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

With no annotations, the description carries the full burden. It does disclose real side effects: files are written to the tmp folder and the folder is auto-created if missing. However it omits overwrite behavior, required authorizations, and what happens to pre-existing files of the same name.

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

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

Three short sentences, front-loaded with the primary action and destination, then the optional include behavior, then the folder-creation side effect. No filler, though the trailing sentence could have been merged.

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 three-parameter export tool with no output schema and no annotations, the description covers destination, optional include scope, and a key side effect. It would be complete at 5 with a note on returned file paths or overwrite semantics, but nothing critical blocks correct invocation.

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

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

Schema description coverage is 100%, so class_name, single_file, and include_types are already documented in the schema. The description only restates the include-export idea ('optionally export all includes') without adding syntax, defaults, or behavior beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Export) and resource (ABAP class) with the destination (file(s) in the tmp folder), which clearly separates it from read-only siblings like GetClass or GetClassInclude. It does not explicitly name a sibling to disambiguate from ImportClassFromFile, so it stops short of a 5.

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

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

Usage is implied by the verb and destination ('export directly to file(s)'), but there is no explicit when-to-use or when-not guidance, and no mention of the inverse ImportClassFromFile sibling or when to prefer GetClass for in-context reading.

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 two useful behaviors: the output location/extension and the automatic Z-namespace name conversion. It is silent on overwrite behavior for an existing file, permission requirements, and failure modes, which are material for a tool that writes to disk.

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, no filler, and the primary action plus output destination are front-loaded before the secondary namespace-conversion note. Every clause carries 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?

No output schema and no annotations exist, so the description must cover behavior alone. It adequately explains what gets produced and where, but leaves an agent unsure about return value, overwrite semantics, and error conditions for a write-to-disk operation.

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

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

Schema coverage is 100% and the single parameter is self-explanatory, so the baseline is 3. The description does add one piece of parameter-relevant meaning beyond the schema: that the supplied function group name is converted to the Z-namespace, so the value passed may not match the file name written.

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 (Export) and resource (ABAP function group) plus the exact artifact produced: a file in the tmp folder with a .fugr.abap extension. This distinguishes it from GetFunctionGroup/GetFunction, which retrieve objects rather than writing them to disk.

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 'directly to a file' implies the export-to-disk use case versus retrieving content via GetFunctionGroup, but no explicit when-to-use or when-not-to-use guidance is given, nor any precondition such as the group needing to exist or the caller needing authorization.

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 it does disclose concrete behavior: output location (tmp folder), file extension (.intf.abap), and automatic Z-namespace name conversion. However, it omits whether existing files are overwritten, whether the interface must already exist, and how failures surface.

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 the destination and naming behavior front-loaded and no filler. Sized appropriately for a simple single-parameter 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 export with no annotations and no output schema, the description covers what gets produced, where, and the naming side effect. Remaining gaps (overwrite behavior, error conditions) are minor for a simple file-export utility.

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 single parameter is already documented, giving a baseline of 3. The description adds genuine value beyond the schema by disclosing that interface_name is automatically converted to the Z-namespace, a transformation the caller should know about.

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 (export), resource (ABAP interface), and destination (a file in the tmp folder with .intf.abap extension). This clearly separates it from the other Export*ToFile siblings by resource type and from GetInterface. It stops short of explicitly signaling the relationship to GetInterface, but the purpose is unmistakable.

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 by the verb and destination (export an interface to disk), but there is no explicit when-to-use guidance or mention of alternatives like GetInterface or the other Export tools. The agent must infer the selection logic from the name and description alone.

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

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

No annotations are provided, so the description carries the full burden. It does disclose genuinely useful behavior: the output lands in the tmp folder, the file gets a .ddlx.asddlxs extension, and the extension name is silently rewritten into the Z-namespace. It omits whether an existing file is overwritten, what filename results, and any authorization 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?

Two tight sentences, front-loaded with the action and output location; nothing is padding. Slightly under-optimized in that the namespace-conversion clause is appended rather than framed as a behavioral warning.

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 export tool with no output schema and no annotations, the description covers what is exported, where it is written, and the name transformation. The main gap is that it never gives the concrete resulting path or filename pattern an agent would need to locate the exported file afterward.

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% for the single extension_name parameter, so the baseline is 3. The description adds only a tangential note that the name is converted to Z-namespace, which is behavior rather than parameter semantics, and adds no format or valid-value guidance 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 (Export) plus resource (CDS metadata extension) and the destination (a file in the tmp folder with .ddlx.asddlxs extension), so an agent can distinguish this from the GetMetadataExtension reader sibling. It stops short of naming any sibling explicitly, so it is clear but not maximally differentiating.

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

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

Usage is only implied: the description makes clear you call this when you want the metadata extension landed on disk rather than returned, and the '.'ddlx.asddlxs'' detail reinforces that. There is no explicit statement of when to prefer this over GetMetadataExtension, no prerequisites, and no exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the exact destination folder and file extension plus an unexpected behavior (automatic Z-namespace conversion), which is real added value. However, it omits whether existing files are overwritten, permission requirements, and what the call returns (e.g., the resulting path).

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 the destination disclosed first, followed by the transformation behavior. No filler, though the second sentence could have absorbed a returned-path detail at little cost.

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 export tool with no output schema, the description covers the file target and extension but leaves the agent guessing about the resulting file path, overwrite behavior, and error conditions. Adequate but with clear gaps.

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

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

Schema description coverage is 100% for the single program_name parameter, so the baseline is 3. The mention of automatic Z-namespace conversion loosely informs how the name value is interpreted, but it does not clarify format or case expectations 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 (Export), resource (ABAP program), and output target (file in tmp folder with .prog.abap extension). This clearly distinguishes it from GetProgram (which returns content rather than writing a file) and from the other Export*ToFile siblings by resource type. It does not explicitly name a sibling, so it falls short of a 5.

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

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

The description never says when to choose this over GetProgram or the other Export*ToFile tools; that it writes to a file is stated as capability, not as a selection condition. The 'use this when you want a file on disk' implication is left entirely to inference. No exclusions or alternatives 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, the description carries the full behavioral burden. 'Retrieve' implies a safe read, but nothing states what happens when the DCL does not exist, whether authorization is required, or what form the returned source takes. For a tool with zero annotation coverage this is a notable 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 front-loaded sentence with no filler; every word earns its place. It is terse to the point of being thin, but not padded.

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

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

For a one-parameter read tool with no output schema and no annotations, the definition covers the core purpose but omits usage routing, failure behavior, and any note on the returned source. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so dcl_name is already documented in the schema and the baseline is 3. The description adds only the 'DCL' acronym context and does not clarify name format or scoping.

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 (Retrieve) and resource (access control (DCL) definition source code), and the DCL expansion clarifies the domain object. It does not, however, distinguish itself from the sibling ExportAccessControlToFile, which an agent could easily confuse with it.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to alternatives such as ExportAccessControlToFile. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. 'Retrieve' implies a read operation, but the description says nothing about permissions, error behavior when no behavior definition exists, or whether the returned metadata includes drafts/authorization info.

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

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

A single, front-loaded sentence with no filler, which is appropriately sized for a one-parameter getter. It is perhaps slightly over-terse, but nothing 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?

With no output schema and no annotations, the description does state what is returned (source code plus metadata), which covers the essentials. It still omits failure modes and access requirements that an agent would benefit from for a repository lookup 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 coverage is 100%, so the sole parameter cds_view_name is fully documented by the schema as 'Name of the root CDS view entity'. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb ('Retrieve') and resource ('RAP behavior definition source code and metadata'), so the agent knows exactly what comes back. It does not, however, distinguish this from the close sibling GetBehaviorForRapBo, which also deals with RAP behavior, leaving some ambiguity about which to pick.

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

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

There is no when-to-use guidance, no stated prerequisites (e.g. that the CDS view must be a RAP root BO), and no mention of the alternative GetBehaviorForRapBo or GetCDSView. The agent must infer context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does little: 'Retrieve' implies a read, and the RONT_NODE source table is disclosed, but there is no statement about permissions, whether the BO must exist/be activated, error behavior when no behavior definition exists, or the shape/size of the returned definition.

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

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

One front-loaded sentence with no filler and no redundancy. The trailing 'from RONT_NODE table' is implementation detail that only marginally helps an agent, but nothing 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?

For a one-parameter read tool with no output schema this is close to minimally viable, but it omits the return-shape description that an output-schema-less tool needs and gives no routing signal against the near-identical GetBehaviorDefinition sibling.

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

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

There is a single parameter (rap_bo_name) with 100% schema description coverage, so the schema already defines its meaning; the description adds no format, naming-convention, or case-sensitivity detail beyond it. 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?

States a specific verb (Retrieve) and resource (interface behavior definition for RAP Business Object), which is clearer than a bare name restatement. However, it never distinguishes itself from the very close sibling GetBehaviorDefinition, nor from SearchRapBo/GetBopfBusinessObject, so an agent cannot tell which of these near-duplicate readers to pick.

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

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

No when-to-use guidance of any kind. The description does not say when this is preferable to GetBehaviorDefinition (the obvious alternative), whether it requires an activated object, or what happens when the BO has no behavior definition.

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 scope of what is retrieved, which is useful, but says nothing about read-only safety, permission requirements, or the cost difference of analyze=true (which loads ABAP source). Adequate but incomplete for an unannotated 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?

A single front-loaded sentence that lists the returned artifacts with no filler. Efficient, though the redundant 'BOPF/BOPF' phrasing slightly detracts.

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, the description must convey the return shape; it does list the top-level artifacts, which is helpful, but does not describe the response structure, depth of nesting, or the heavier cost of the analyze path. Sufficient to call the tool, not to anticipate its output.

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

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

Schema description coverage is 100%, so both parameters (bo_name and analyze) are fully documented in the schema, including the meaning of analyze=false vs true. The description adds no parameter detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Retrieve) and resource (BOPF Business Object definition) and enumerates the returned content (nodes, properties, associations, actions, determinations, validations). It is distinguishable from the sibling SearchBopfBusinessObjects, though the 'BOPF/BOPF' duplication is a small wording defect and no sibling is named 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?

There is no when-to-use or when-not-to-use guidance and no alternatives named. An agent must infer that this fetches a single known BO by name rather than searching, and gets no cue about when GetBehaviorForRapBo or GetBehaviorDefinition would be preferable.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It implies a read-only operation but says nothing about authorization requirements, which system/version is read, response size limits, or whether inactive versions 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?

A single short sentence, front-loaded with the verb and resource, with no wasted words. It is efficient, though arguably under-specified rather than genuinely concise.

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

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

With no annotations and no output schema, the description should clarify what 'metadata' comprises versus source code, the relationship to GetCDSViewContents, and any system/permission context. It leaves all of that 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 description coverage is 100%, so both parameters (view_name, include_annotations) are already documented with defaults. The description adds nothing beyond the schema, which is the baseline-3 case.

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

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

States a clear verb ('Retrieve') and resource ('CDS view') with two outputs (source code and metadata). However, it does not distinguish itself from the near-identical sibling GetCDSViewContents, nor from ExportCDSViewToFile, leaving an agent unable to tell which to pick.

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

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

There is no when-to-use guidance, no prerequisites (e.g., active system, required authorizations), and no mention of the alternative tools (GetCDSViewContents, ExportCDSViewToFile) that an agent must choose between.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds pagination and batch-mode context, but omits the read-only nature, the result-size ceiling behavior, or the batch cap (max 5) — those constraints live only in the schema, so the description's own behavioral disclosure is thin.

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

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

Two tightly written sentences: capability summary first, then the mode-selection rule. Zero filler and front-loaded.

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

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

Covers the mode-selection logic adequately, but with no output schema and nested batch objects, the description says nothing about the shape of results (or how batch results are keyed by id). For a 9-parameter tool with nested structures, this leaves a real gap.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters in detail (e.g., the max 500 rows, max 5 batch limit, ADT equality-only note). The description adds marginal value by clarifying the view_name vs queries selection rule, which the schema only implies.

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 (query) and resource (CDS view data) plus the supported capabilities (filtering, pagination, parameters, batch). This clearly distinguishes it from the sibling GetCDSView (metadata retrieval), though it never names that sibling to reinforce the 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?

Explicitly defines the two modes and their mutual exclusion: 'Either provide view_name for a single query, or provide queries array for batch mode.' Clear operational context, but no guidance on when to prefer batch over repeated single calls, nor any exclusions relative to GetCDSView/ExportCDSViewToFile.

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. 'Retrieve' correctly implies a read-only operation, and it discloses that includes are fetched in a single call and that structured output is JSON. It says nothing about output size, volume of source returned for large classes, or any permission/authorization requirement, which are real concerns for a source-retrieval 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?

Two tight sentences, front-loaded with the core retrieval action, then the optional include behavior, then the output-format tip. No filler and no repetition of schema text.

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 3-parameter read tool with no output schema and no annotations, the description covers purpose and both optional parameters adequately. It falls short on sibling disambiguation for includes and test classes and on what a caller receives for large classes, which are the main gaps an agent would need closed.

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 baseline is 3. The description goes slightly beyond the schema by explaining why 'structured' matters (JSON-aware compression) and by implying the default recommendation of structured with the default include type. It still adds no meaning for class_name or for the interaction between include_types and output_format beyond what the schema states.

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 ('Retrieve ABAP class source code') and enumerates the optional include types, so the agent knows exactly what comes back. However, it never distinguishes itself from close siblings like GetClassInclude, GetClassTests, or ExportClassToFile, even though it visibly overlaps with them by offering include fetching.

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 conditional guidance for one parameter ('Use output_format=structured for JSON output suitable for downstream compression') which implies when to prefer structured output. It offers no guidance on when to call this tool rather than GetClassInclude for includes, GetClassTests for test classes, or ExportClassToFile for persistence, so selection among siblings is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It indicates tests are run (a side-effecting action) but omits permissions, activation side effects, reversibility, and output format—only minimal behavioral context is given.

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

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

A single, front-loaded sentence with no redundant or filler content. It efficiently communicates the tool's action and result.

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 more about what running tests entails (e.g., side effects, activation behavior) and what coverage results include. It is too sparse for a tool with side-effect potential and optional activation flags.

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%, fully documenting class_name, auto_activate, and preaudit_requested. The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific action (run unit tests for a class) and result (test coverage), making the core purpose clear. However, it does not differentiate from sibling tools like RunClassTests or GetClassTests, leaving ambiguity about when this tool is preferred over them.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. It does not mention alternatives such as RunClassTests or GetClassTests, so the agent must infer that this tool is for coverage rather than plain test 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but says nothing about permissions/authorization, behavior when the include does not exist, or what form the result takes — significant gaps for a tool with zero annotation coverage.

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

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

A single tight sentence with the verb and resource front-loaded and the enumerated variants parenthesized at the end; nothing is wasted. It is appropriately sized for a two-parameter read 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?

With no output schema and no annotations, the description should carry more: it never says the tool returns source code and never positions itself against GetInclude/GetClass. Adequate to invoke correctly, but thin given the missing structured 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 100% and the include_type enum already documents each value, including the CCDEF/CCIMP/CCMAC/CCAU mapping. The description only restates the same value list, adding no syntax, format, or edge-case meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Retrieve') and resource (a specific include of an ABAP class) and enumerates the five include kinds, so the agent knows exactly what comes back. It does not explicitly distinguish itself from the nearby siblings GetClass and GetInclude, which likely overlap in scope, so it stops short of a 5.

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

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

There is no when-to-use guidance at all: nothing says when to call GetClassInclude versus GetClass (whole class) or the generic GetInclude. The list of include_type values implies the options but not the selection conditions, so an agent must infer the 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 full disclosure burden. It does not say whether the call is read-only, whether the class must exist/is local, whether it returns source text or just names, or how multiple test classes are represented. Only 'local' hints at scope.

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

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

A single, front-loaded sentence with no filler. It is efficient, though the extreme brevity borders on under-specification rather than purposeful 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?

With no annotations and no output schema, the description is the only source of behavioral and return-value information, and it supplies neither. For a tool whose output shape (names vs. source code) materially affects how an agent uses it, this is a clear gap.

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

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

Schema description coverage is 100% and the single parameter (class_name, 'Name of the ABAP class') is fully documented in the schema. The description adds nothing beyond what the schema already provides, so the baseline of 3 applies.

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

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

States a specific verb+resource: retrieving 'local test classes' from a given class. This is reasonably distinguishable from RunClassTests (executes tests) and CreateClassTests (creates them), though it doesn't explicitly contrast itself with GetClassInclude, which may also expose test includes.

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 statement of when to use this tool versus RunClassTests, GetClassInclude, or GetClass. The agent must infer the context entirely 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?

No annotations are provided, so the description carries the full burden; it does disclose the deprecation lifecycle and imminent removal, which is valuable behavioral context. However, it says nothing about permissions, whether it still functions identically to the successor, error behavior, or result shape for a read operation.

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

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

Two short sentences with the deprecation warning front-loaded and bracketed, so an agent sees the critical routing information before anything else. No wasted text.

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, read-only tool with no output schema and no annotations, the definition supplies what an agent most needs: what it does and what to use instead. It could add one clause on whether the deprecated tool still returns the same data as GetObjectUsages, but 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?

Schema description coverage is 100% for the single class_name parameter, so the schema already documents the input fully. The description adds no format, naming, or scoping detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Retrieve usages for an ABAP class') and immediately names the successor tool GetObjectUsages, so an agent can distinguish it from siblings like GetClass or GetObjectUsages without opening the schema.

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 explicit when-not guidance ('DEPRECATED - Use GetObjectUsages instead' plus 'will be removed in a future version') and names the exact alternative to use in its place, which is the strongest possible routing guidance for a deprecated 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, the description carries the full disclosure burden. It implies a read-only retrieval and names the returned content (domain reference, field labels, documentation), which is genuine added value, but it says nothing about permission/auth requirements, which system the lookup targets, or behavior for an unknown data element name.

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

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

A single front-loaded sentence with no filler; the verb, resource, and returned fields are all delivered immediately.

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

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

For a one-parameter read tool with no output schema, the description is nearly sufficient because it enumerates the key returned fields. The remaining gap is that it omits any note on return shape, failure modes, or system context, which siblings like ListSystems/SetDefaultSystem imply is relevant.

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% for the single parameter, including concrete examples (MATNR, BUKRS, NETWR), so the schema does the work. The description adds no additional meaning about naming conventions, case sensitivity, or namespace scoping beyond what the schema already supplies.

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

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

States a specific verb (Retrieve) and resource (ABAP data element definition) and enumerates the payload (domain reference, field labels, documentation). It does not explicitly contrast itself with the adjacent sibling GetDomain, though naming 'domain reference' as content rather than the domain itself hints at the 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 statement of when to use this tool versus GetDomain, GetTable, or GetStructure, which all sit in the same metadata-retrieval family. Usage is only inferable from the name and the phrase 'data element definition'; no prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only lookup and describes the payload contents, but says nothing about error behavior for unknown domains, authentication/system prerequisites, or whether results are cached. For an annotation-free tool this is thin.

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

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

A single front-loaded sentence with the resource and the returned fields, no filler or redundancy. 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?

With no output schema, the description must convey return content, and it lists the key result fields (data type, length, fixed values, conversion exit). It is largely sufficient for a single-parameter lookup, though usage context and failure behavior are 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?

Only one parameter exists and schema coverage is 100%; the schema itself supplies the parameter description plus examples (MATNR, BUKRS, LIFNR). The description adds no additional meaning about the domain_name argument, so it sits at the baseline for fully documented schemas.

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

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

States a specific verb ('Retrieve') and resource ('ABAP domain definition') and enumerates the returned content (data type, length, fixed values, conversion exit), which cleanly separates it from sibling getters like GetDataElement or GetTable. It does not explicitly say how it differs from GetDataElement, but the resource is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as GetDataElement, GetTable, or GetTypeInfo, nor any preconditions (e.g., domain must exist, system must be selected). The agent must infer usage entirely from the name and resource.

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

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

No annotations are provided, so the description carries the full burden. It only states the action without disclosing side effects, permissions, error handling, or output format.

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?

Single sentence, front-loaded with key information, no wasted words. Could be expanded slightly but maintains 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 retrieval tool with two parameters and no output schema, the description minimally indicates the resource but lacks details on what the source code output looks like or any limitations.

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% with basic descriptions for both parameters. The tool description adds no additional meaning beyond the schema.

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

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

The description clearly states the action ('Retrieve') and the resource ('ABAP Function Module source code'), which distinguishes it from sibling tools targeting other object types like GetClass or GetProgram.

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

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

No explicit guidelines on when to use this tool vs. alternatives, but the resource name and sibling tool names make the context 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?

Without annotations, the description must fully convey behavioral traits. It only states 'Retrieve', implying a read operation, but fails to mention error handling, permissions, or what happens if the function group does not exist.

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

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

The description is concise and front-loaded, using a single sentence. However, it sacrifices completeness for brevity, missing context that could improve usability.

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 absence of output schema and annotations, the description is incomplete. It does not specify the format of the source code, limitations, or error handling, leaving the agent underinformed.

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 already describes the single parameter as 'Name of the function module' with 100% coverage. The description adds no additional semantic value beyond what the schema provides.

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

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

The description specifies the verb 'Retrieve' and the resource 'ABAP Function Group source code', clearly indicating the tool's function. It distinguishes from siblings like GetFunction (which retrieves a function module) and GetProgram.

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 GetFunction or GetInclude. The description lacks any context for appropriate usage.

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

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

No annotations provided, so the description carries full burden. It only states the retrieval action but does not disclose safety, authorization needs, or behavior when include is not found. For a mere retrieval tool, this is minimal transparency.

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

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

The description is a single, clear sentence with no redundant words. Every word adds value, achieving maximum 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 retrieval tool with one parameter and no output schema, the description is minimally adequate. It covers the primary purpose but lacks details on return format, error handling, or prerequisites, which could help the agent.

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

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

Schema description coverage is 100%, and the parameter is adequately described as 'Name of the ABAP Include'. The tool description adds no further meaning beyond the schema, which is acceptable given high 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 uses a specific verb 'Retrieve' and resource 'ABAP Include Source Code', clearly indicating the tool's function. However, it does not differentiate from sibling tools like GetProgram or GetFunction, which also retrieve source code for different ABAP objects.

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

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

No guidance on when to use this tool versus siblings such as GetProgram or GetFunction. There is no mention of prerequisites, context, or exclusions.

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

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

No annotations provided, so description must bear full burden. Only states retrieval, but lacks details on side effects, authentication, or output constraints. Insufficient for a read 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?

Extremely concise single sentence, no unnecessary words. Lacks structural elements like bullet points, but efficiency earns a high 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?

No output schema or annotations; description fails to explain return format, prerequisites, or how it differs from 12 siblings. Incomplete for a tool in this 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 coverage is 100% for the single required parameter (interface_name). Description adds no extra meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

Clearly states verb 'Retrieve' and resource 'ABAP interface source code'. However, does not differentiate from sibling tools like GetClass or GetFunction that also retrieve source code, preventing a 5.

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

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

No guidance on when to use this tool versus alternatives like GetTypeInfo or SearchObject. Description is minimal with no context for 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 provided, so the description carries the full behavioral burden. 'Retrieve' reasonably implies a read-only operation and 'source code' discloses the return content, but nothing is said about failure modes (e.g., unknown extension_name), size, or permissions. Partial disclosure for an annotation-free getter.

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

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

A single short sentence with no filler, front-loaded with the verb and resource. Efficient, though it is arguably too terse to route the agent among siblings.

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

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

For a one-parameter read tool with no output schema this is close to adequate, but given no annotations and a crowded sibling set including ExportMetadataExtensionToFile, the description should say more about when this read is preferable and what it returns.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents extension_name fully. The description adds nothing beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb (Retrieve) and resource (metadata extension source code), and parenthetically clarifies that a metadata extension holds UI annotations. It implicitly separates itself from ExportMetadataExtensionToFile by returning source code rather than a file, but never names the sibling, so the differentiation is left to inference.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as ExportMetadataExtensionToFile. The agent must guess whether this is the right tool when it wants the extension contents or a file export.

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 and mostly does not: it says nothing about whether this is a read-only (it is implied by 'Retrieve'), how expensive a comprehensive where-used scan is, whether results are paginated, or what happens with unresolved objects. The one useful disclosure, 'comprehensive', is left vague.

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 the core purpose front-loaded and no filler. It is efficient, though the second sentence spends its budget on a filtering claim that partly mismatches the 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?

An 11-parameter tool with no annotations and no output schema needs more than this; the description never indicates the shape of the returned usage list (elements vs. definitions vs. metadata blobs) even though include_elements, include_definitions, and include_metadata all toggle it. An agent cannot predict result size or structure from the description.

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 every parameter is already documented, which sets the baseline at 3. The description adds little, and its claim of filtering by 'usage grades' maps to no parameter in the schema, a small inaccuracy rather than added 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?

States a specific verb and resource ('Retrieve comprehensive where-used list for ABAP objects') and enumerates the object kinds it covers, which implicitly separates it from the narrower GetClassUsages sibling. It never names that sibling or any other alternative, so differentiation is left to inference.

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

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

No statement of when to use this versus GetClassUsages, GetPackageContents, or SearchObject, and no prerequisites or exclusions. 'Supports filtering by object types and usage grades' hints at capability but not at when this tool is the right choice.

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 usefully enumerates the categories of information returned (hierarchy, transports, interfaces), which is real behavioral disclosure, but it never states that the call is read-only, what permissions are needed, or the response format, leaving notable gaps for a zero-annotation 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?

A single front-loaded sentence with the verb and resource leading and the returned categories trailing as a list. No filler, though the enumeration is dense and could be trimmed.

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, the description compensates by enumerating what the caller receives (metadata, attributes, hierarchy, transports, application component, interfaces). For a single-parameter read tool this is nearly sufficient; only the response shape/pagination remain 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?

There is one required parameter and schema description coverage is 100%, so the schema already fully documents 'package_name'. The description adds no syntax, format, or naming-convention detail beyond the schema, which is the baseline-3 case.

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

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

States a specific verb (Retrieve) and resource (ABAP package information) and enumerates the categories returned: metadata, attributes, hierarchy, transport details, application component and interfaces. It does not explicitly distinguish itself from the sibling GetPackageContents, which is the most likely confusion point, so it stops short of a 5.

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

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

The description gives no when-to-use guidance, no prerequisites, and never names an alternative such as GetPackageContents for listing contained objects. Usage is only implied by the 'Get<Object>' naming convention.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieve' implies a read-only operation, but there is no explicit confirmation, no note about permissions/authorization needed to read a package, no rate or scope limits, and no indication of what the response contains or how large it might be. For a tool with zero annotation coverage this is thin.

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

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

A single front-loaded sentence with no filler; the resource comes first and the option follows. It is efficient, though the brevity is partly what leaves the stated gaps rather than an intentional trade-off.

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, no output schema, and two boolean parameters whose semantics overlap (recursive vs. include_subpackages), the description should resolve that ambiguity and describe the return shape. It instead leaves the agent to infer how the two flags interact and what a 'contents' result looks like.

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 three parameters, establishing the baseline of 3. The description echoes the recursive behavior but adds nothing about the potentially confusing overlap between the `recursive` and `include_subpackages` booleans, which is exactly where added semantic value would help.

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 ('Retrieve') and resource ('objects and contents within an ABAP package'), so the agent knows exactly what it returns. However, it does not differentiate itself from the sibling GetPackage, which an agent could easily confuse with this tool. Clear but not sibling-aware.

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

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

The description gives no when-to-use or when-not-to-use guidance, and never mentions the adjacent GetPackage or SearchObject tools. The recursive option is described as a capability, not as a condition that should drive tool selection. Only implied usage is available.

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

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

Without annotations, the description carries full burden. It states a read operation but does not disclose authorization needs, error handling, size limits, or return format—minimal behavioral insight.

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 redundant words. However, it is almost too minimal, lacking detail that could be provided without bloat.

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 retrieval tool with one parameter and no output schema, the description is passable but incomplete—it hints at the return value but does not specify the format or any additional context like rate limits or prerequisites.

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 full coverage (100%) with a clear description for 'program_name'. The tool description adds no extra meaning beyond the schema, meeting baseline but not exceeding it.

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 ('Retrieve') and clarifies it returns 'ABAP program source code', making the tool's function clear and distinguishing it from siblings like GetClass or GetFunction.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any conditions or prerequisites. The sibling list implies differentiation by object type, but no explicit direction is 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?

No annotations are provided, so the description carries the full burden. It does disclose what the response contains (error analysis, call stack, variables, source code extract), which is useful for a read tool, but says nothing about permissions, encoding requirements beyond the schema note, or behavior of the content modes.

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

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

Two sentences with zero waste: the first establishes purpose and scope, the second enumerates the return payload. It is well front-loaded with nothing extraneous.

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

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

For a two-parameter read tool with no output schema, the description supplies the return-content summary that would otherwise be missing, and the schema covers parameters. Only the missing usage routing and permission context keep it from being fully complete.

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

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

Schema coverage is 100%, so both dump_id and the content enum are already fully documented in the schema, including the URL-encoding caveat. The description adds no syntax or format detail beyond restating that formatted output is the default behavior.

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 ('Retrieve detailed information about a specific runtime error dump') and pins the domain with the ST22 transaction code. The word 'specific' implicitly contrasts with ListRuntimeErrors, but no sibling is named explicitly, so it falls just short of the top band.

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

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

No when-to-use guidance is given. It does not say the dump_id must first come from ListRuntimeErrors, nor when a caller would choose this over the list tool or vice versa. That linkage exists only in the dump_id schema description, not in the tool description.

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. 'Retrieve' implies a read-only operation, which is the key behavioral signal, but there is no mention of permissions, error behavior, or the shape/volume of what comes back. For a simple one-parameter getter this is acceptable but thin.

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

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

A single, front-loaded sentence with no wasted words. It is efficient, though its brevity borders on under-specification given the absence of annotations.

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 trivial one-parameter read tool with no output schema, the description is nearly sufficient — it names the resource and what is returned. It falls short only on usage context and any behavioral nuance.

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?

Single parameter with 100% schema description coverage, so the schema fully documents binding_name. The description adds nothing beyond the schema, making the baseline 3 correct.

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 (Retrieve) and resource (RAP service binding) plus what is returned (details and configuration). The resource is distinct from siblings like GetServiceDefinition and GetBehaviorDefinition, so an agent can tell it apart, though it never explicitly contrasts with them.

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

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

No indication of when to use this tool versus alternatives, no prerequisites, and no routing guidance. The agent must infer usage purely from the tool name and resource.

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

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

No annotations exist, so the description carries the full burden; it does disclose that both source code and metadata are returned, which is real behavioral value. However, it says nothing about authorization requirements, error behavior when the service does not exist, or the format of the returned source.

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

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

A single front-loaded sentence that names the action, the resource, and the return content with no wasted words. Nothing is buried or redundant.

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

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

For a one-parameter read tool with a fully documented schema this is close to adequate, and it does state what is returned. But with no output schema and no annotations, the absence of any detail on return format or failure modes leaves a noticeable gap.

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

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

The single parameter is fully documented in the schema at 100% coverage, so the schema already does the work. The description adds no naming-convention or format guidance (e.g., package-qualified vs. plain name), so the baseline of 3 applies.

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

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

States a specific verb (Retrieve) and resource (RAP service definition) and clarifies the payload is source code plus metadata. It distinguishes itself adequately from CreateServiceDefinition and GetServiceBinding by naming the artifact type, though it never explicitly contrasts with those siblings.

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

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

There is no guidance on when to use this versus GetServiceBinding, GetBehaviorDefinition, or the many other Get* siblings, and no prerequisites stated. Usage is only implied by the name and the read verb.

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

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

No annotations are provided, so the description must bear the full burden of behavioral disclosure. It only says 'Retrieve', which implies a read operation, but does not state what is returned, whether it is safe, or any side effects. The complete lack of behavioral details is insufficient.

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 at four words, but it is under-specified lacking essential context. While concise, it does not earn its place as it fails to provide sufficient information for effective tool selection.

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

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

Given the tool's simplicity (one parameter, no output schema), the description should at least indicate what kind of data is returned (e.g., structure fields). The current description is too sparse to be complete.

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

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

Schema description coverage is 100% for the single parameter 'structure_name', which is described as 'Name of the ABAP Structure'. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description 'Retrieve ABAP Structure' clearly states the action (retrieve) and the resource (ABAP Structure). It distinguishes from siblings like GetClass or GetTable by specifying the object type 'Structure', though it lacks elaboration on what exactly is retrieved (e.g., metadata, definition).

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

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

The description provides no guidance on when to use this tool versus alternatives like GetTable or GetClass. There is no mention of prerequisites, context, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses return contents (URL, client, auth method, reachability) and warns against prerequisite use, but it does not explicitly state read-only/side-effect-free behavior or whether calling it may trigger authentication or network 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?

Three well-structured sentences: the first lists returned data, the second and third give clear usage constraints. Every sentence earns its place and the critical scoping warning 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 zero-parameter diagnostic tool with no output schema and no annotations, the description fully covers what the tool returns and when it should or should not be used. An agent has everything needed 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?

Zero parameters, so the baseline is 4. No parameter semantics are needed, and the description appropriately focuses on return values and usage context instead.

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?

Specific verb (Returns) and resource (active SAP ABAP backend connection details), with enumerated return fields and a clear scope. It distinguishes itself from the many sibling ABAP object tools by stating it is for connectivity troubleshooting, not for reading objects.

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

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

Explicitly states when to use (ONLY for troubleshooting ADT connectivity or confirming the targeted backend) and when NOT to use (not as a prerequisite for other ABAP operations). It also explains that all other tools establish the ADT connection automatically, which is a direct alternative behavior.

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

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

With no annotations, the description carries full burden, but it only states the basic action. It omits behavioral details such as whether any prerequisites or side effects exist, or the format of the returned structure.

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 with no filler, but extremely brief. While concise, it might sacrifice necessary detail.

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

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

Given no output schema and no annotations, the description should explain what 'table structure' entails (e.g., fields, keys). It fails to provide a complete picture, leaving ambiguity.

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

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

The input schema covers the single parameter fully with a description, and the tool description adds no extra semantics. Baseline 3 is appropriate as schema coverage is 100%.

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 'Retrieve ABAP table structure' uses a specific verb and resource, clearly distinguishing it from siblings like GetTableContents (which retrieves data) and GetStructure (which may refer to other dictionary structures).

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

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

The description implies use for structure retrieval, and sibling names suggest alternatives like GetTableContents for data, but no explicit guidance on when or why to choose this tool over others.

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. The verb 'Retrieve' implies a read-only operation and batch mode is disclosed, but there is no mention of permissions, whether results are capped (schema holds the 500-row/10-query limits), or response behavior. Adequate but thin for a no-annotation 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?

Two tight sentences, front-loaded with the core capability and then the mode-selection rule. No filler, no restatement of the tool name, every clause carries information.

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

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

The mode-selection ambiguity is covered and the schema is fully annotated, but there is no output schema and the description never explains what the response looks like (row shape, how batch results are keyed by id, effect of include_column_metadata). For an 8-parameter tool with nested batch objects and no output schema, that is a real gap.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema, including the equality-only constraint on where_conditions and column validation. The description adds only a high-level mention of filtering/pagination/batch and no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Retrieve contents of an ABAP table') and names its distinguishing capabilities (filtering, pagination, batch). The word 'contents' implicitly separates it from metadata-oriented siblings like GetTable, but no sibling is named explicitly, so it stops short of a 5.

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

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

Explicitly states the selection rule between its two modes: table_name for a single query, queries array for batch mode. That is clear, actionable context, but there is no guidance on when to prefer this tool over sibling lookup tools such as GetTable or GetStructure, and no exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'retrieve', implying a read-only operation, but does not explain authentication needs, error handling, or what happens if the transaction does not exist. This is insufficient for a tool with no annotations.

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

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

The description is a single, concise sentence that front-loads the purpose. It contains no unnecessary words. However, it could be slightly expanded to include key details without losing conciseness.

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

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

Given the tool has no output schema and simple input, the description should at least hint at the output structure or what 'details' entails. It does not, leaving ambiguity. For a retrieval tool, the absence of return value information is a notable gap.

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

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

Schema coverage is 100% with the parameter 'transaction_name' having a description 'Name of the ABAP transaction'. The tool description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description 'Retrieve ABAP transaction details' clearly identifies the action (retrieve) and the resource (ABAP transaction details). It distinguishes from sibling tools like GetProgram or GetTable by specifying 'transaction'. However, 'details' is vague and could be more 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?

The description provides no guidance on when to use this tool versus alternatives such as GetProgram or GetTable. The context is only implicit through the tool name and sibling list. No explicit when/when-not or alternative suggestions 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, the description carries the full burden and does disclose non-obvious behavior: that transports are task/request hierarchies and that version history may attach to the parent. It stops short of stating the read-only safety profile or permission requirements.

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

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

Three sentences, front-loaded with the retrieval purpose, then the ordering imperative, then the return shape. Every sentence adds distinct value 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?

No output schema exists, but the description compensates by naming the return contents (hierarchy, objects, next-step guidance). The missing piece is any statement of the read-only nature or auth context for a tool with zero annotation coverage.

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

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

Schema description coverage is 100% with a single documented parameter, so the baseline is 3. The description adds no format or constraint details beyond the schema's example (e.g., ER1K8AKL0L).

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 ('Retrieve detailed transport information') and narrows the scope to 'task/request hierarchy and object list,' which separates it from the version-oriented sibling GetTransportVersions. An agent knows exactly what this returns without opening the schema.

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 explicit ordering guidance ('Use this FIRST when analyzing a specific transport') with a rationale tied to version history being recorded under the parent request. It does not name when NOT to use it or point to a named alternative, so it stops short of a full 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 must carry the behavioral burden. It usefully discloses that it automatically resolves task/parent request hierarchy and finds relevant versions, which is non-obvious behavior beyond the schema. However, it says nothing about permissions, output/return shape, or limits, leaving significant gaps 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?

Three front-loaded sentences with no filler; the core function is stated first, followed by behavior and a routing recommendation. Slight redundancy between 'combines ... in one command' and 'helper tool,' but overall tight and well-ordered.

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

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

For a 3-parameter tool with no annotations and no output schema, the description covers purpose and key automatic behavior but omits return format and any safety/permission context. It is adequate to invoke correctly but not fully complete given the absence of structured behavioral metadata.

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

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

Schema description coverage is 100%, so all three parameters (transport_number, object_name, object_type) are already well documented in the schema. The description adds only the contextual point that the transport number may be a task or parent request, which the schema also states, so it does not meaningfully extend parameter meaning beyond the structured fields.

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 combined purpose: merging transport analysis and version history given a transport number and object. It distinguishes itself as 'the recommended starting point for analyzing what changed in a specific transport,' which differentiates it from single-purpose siblings like GetVersionHistory and CompareObjectVersions, though it never names them 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?

It gives clear context for use ('recommended starting point for analyzing what changed in a specific transport') and hints at follow-on work ('suggests comparison steps'), implicitly positioning itself ahead of CompareObjectVersions. It stops short of explicit when-not guidance or naming the alternatives it supersedes.

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?