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 kind of information returned and its pre-remediation role, but it does not explicitly state that the operation is read-only, nor does it describe pagination behavior or any failure/error conditions. This is adequate but has clear gaps.

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

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

Two sentences with no fluff: the first states the core purpose and key outputs, the second gives actionable guidance on when to use the tool. The most important information is front-loaded.

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

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

For a relatively simple inspection tool, the description covers purpose, when to use it, and the principal return values. It does not explain how maxLines/startLine affect a call, but the schema already documents those parameters, and the absence of an output schema is partially compensated by the mention of returned fields.

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

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

Parameter schema coverage is 100% and the schema descriptions for maxLines, startLine, and cds_view_name are already clear and detailed. The description mentions the CDS view name naturally but adds no substantive semantics 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 names a specific verb ('Check'), a specific resource ('SAP release classification of a CDS view'), and enumerates the key returned fields (API state, successor, base view, extensibility). This clearly distinguishes it from sibling tools like GetCDSView and RemediateObject.

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

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

The description explicitly states when to use it: 'Use this before remediating to understand what needs to change.' This gives clear contextual guidance, though it does not name exclusions or compare itself to alternative tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the dry_run default, which is already present in the schema, and does not disclose what happens when dry_run=false (e.g., actual creation in SAP), permissions required, or reversibility. This is a meaningful gap for a mutating tool.

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

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

The description is two sentences with no filler: the purpose is front-loaded, the usage condition is explicit, and the dry_run default is mentioned succinctly. Every sentence earns its place.

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

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

Despite thorough schema coverage, there is no output schema and no annotations, so the description must do more work. It does not explain what the tool returns in dry_run mode, what happens when dry_run is false, or account for the seemingly unrelated pagination parameters (maxLines, startLine) present in the schema. An agent could call it confidently for a dry run but would lack critical context for a real creation.

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

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

Schema description coverage is 100%, so the baseline is 3 even without additional parameter detail in the description. The description does not add meaningful semantics beyond the schema, except to emphasize the dry_run default, which is already documented.

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

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

The description names a specific verb and resource: 'Create a CDS View Extension (extend view entity) to add missing fields to an existing SAP standard view.' This clearly differentiates it from the sibling CreateCDSObject, which creates a new CDS object rather than extending an existing standard view.

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

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

It provides a clear usage condition: 'Use when a successor view is missing fields needed by the Z object.' However, it does not explicitly mention when not to use it or point to a specific alternative, so it falls short of full when/when-not guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses the default dry_run behavior and that it creates a scaffold for review. It does not detail the creation side effects (e.g., transport requirements) but the schema covers those parameters, and the clean core safety note adds context.

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

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

Three sentences, each adding distinct value: the core action and context, the use case, and the default behavior with guidance. The information is front-loaded and there is 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?

Given the tool's complexity (10 parameters), the schema already documents each parameter thoroughly. The description adds essential context about when to use it and the dry_run default, which is sufficient for an agent to invoke it correctly. It does not describe the return format, but that is acceptable given the 'review the scaffold' hint.

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 parameters are documented. The description adds the key behavioral detail that dry_run defaults to true and that a scaffold is produced, which reinforces the dry_run parameter's purpose. This goes slightly beyond the schema's description, so it earns a 4.

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

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

The description clearly states the tool creates a new Z wrapper CDS view, specifies it is Level A clean core safe, and that it is for P4 cases with no SAP successor. This distinguishes it from sibling tools like CreateCDSExtension, which serves a different purpose.

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

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

It explicitly states when to use this tool (P4 cases, no SAP successor) and advises reviewing the scaffold before creating via the default dry_run behavior. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to decide.

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

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

No annotations are provided, so the description must carry the full burden. It discloses the return type (prioritized list) and pagination, but does not explicitly state whether the scan is read-only, mention performance implications, or note any authentication requirements. As a scanning tool it is likely read-only, but this is not stated, and no limitations or error conditions are disclosed.

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

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

The description is exactly two sentences with no fluff. The primary purpose is front-loaded, and the pagination hint is succinct. It is efficiently sized and easy to parse.

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

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

The description explains the output (prioritized list of violations with successor recommendations) and the scope (Z/Y custom objects). It does not explain the meaning of P1-P4 or the distinction between the two pagination systems, but the schema covers parameters. Given no output schema, the description provides enough for an agent to understand the return type. It could be more complete by clarifying pagination options, but it is adequate.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a hint about pagination using max_objects and start_index, but does not mention the alternative maxLines/startLine parameters or clarify the distinction between the two pagination mechanisms. The description provides minimal added value beyond the schema.

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

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

The description states a specific action (scan) on a defined resource (Z/Y custom objects) targeting a particular condition (usages of unreleased/deprecated CDS views) and returns a prioritized list with recommendations. This clearly differentiates it from sibling getter tools like GetCDSView or CheckReleaseState.

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 a concrete usage instruction: 'Use max_objects and start_index to paginate large systems.' It implies the tool is for scanning, but does not explicitly compare to alternatives or state when not to use it. The context is clear enough for a scanning operation, but lacks explicit exclusions or alternative routing.

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

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

With no annotations provided, the description carries the full behavioral burden. It usefully discloses the system requirement (~NW 7.54 / S/4HANA) and the paging behavior, but it does not describe the return format, error behavior, or confirm read-only semantics beyond the word 'Retrieve'.

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

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

The description is two sentences with no filler, front-loads the core purpose, and places the paging guidance exactly where it is actionable. Every word contributes value.

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 fully documented parameters, the description provides the necessary prerequisite and paging context. It omits an explicit return-format statement, but 'source code' is sufficient given the tool's purpose and name.

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 documents all three parameters at 100% coverage, so the baseline is 3. The description reinforces the paging parameters but does not add meaning beyond the schema, such as format details or edge-case 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 uses a specific verb ('Retrieve') and a precise resource ('RAP Behavior Definition (BDEF) source code'), making the tool's function unambiguous. The object type is unique among the sibling tools, so an agent can distinguish it without needing to inspect other definitions.

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 guidance on when to use startLine/maxLines for paging large definitions. It does not explicitly discuss alternatives or exclusions, but the sibling tools are all different object types, so selection is already self-evident.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that large views may need paging and that retrieving everything at once is possible but potentially problematic. It does not mention response format or error behavior, but 'Retrieve' implies a read operation and the paging trait is genuinely useful.

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

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

Two sentences with no filler. The core action is front-loaded, and the paging guidance is a single concise follow-up. Every sentence earns its place.

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

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

For a simple retrieval tool with three well-documented parameters, the description covers the essential action and the key paging behavior. It leaves minor gaps like return-format details, but those are largely implied by 'source code' and covered by sibling 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%, so the baseline is 3. The description adds value by tying startLine/maxLines to a usage scenario ('For large views'), giving agents a decision rule beyond the schema's parameter-level descriptions.

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

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

The description states a specific verb and resource: 'Retrieve CDS view (DDL source) source code.' This clearly distinguishes it from sibling tools like GetTable or GetProgram, which target different object types, so an agent can easily tell what this tool operates on.

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 paging guidance ('For large views, use startLine/maxLines to page through the source instead of retrieving it all at once'), which is useful contextual usage advice. However, it does not explicitly compare this tool to alternatives or state when to choose it over sibling Get* tools.

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

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

No annotations are present, so the description carries the full behavioral burden. It discloses paging capability and hints at byte limits through parameter descriptions, but does not address error handling, permissions, or return format. For a read-only retrieval tool, this is acceptable but minimal, warranting a 3.

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

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

The description is a single, efficient sentence that front-loads the core action and immediately provides actionable paging advice. There is no redundancy or filler, making it appropriately concise and well-structured.

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

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

The tool is relatively simple, and the schema covers parameter behavior well. However, the absence of an output schema and lack of description about the return format or potential errors leaves some gaps. The paging guidance is helpful, but the description does not aid in choosing this tool over siblings, making completeness adequate but not thorough.

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 provides 100% description coverage for all three parameters, including detailed behavior for startLine and maxLines. The tool description adds no new parameter semantics beyond reinforcing paging, so it meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'Retrieve' and the resource 'ABAP class source code', making the purpose unambiguous. It does not explicitly differentiate from sibling tools like GetProgram or GetInterface, but the resource type is specific enough. This aligns with a 4: clear but no explicit sibling differentiation.

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

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

The description gives paging guidance for large classes, which is useful usage context, but it does not mention alternatives or when not to use this tool. It implies usage for retrieval but lacks explicit exclusions or comparisons to siblings. This fits an implied usage scenario with no alternatives provided.

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

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

With no annotations, the description carries the disclosure burden; it reveals that retrieval can be large and supports paging via startLine/maxLines. However, it doesn't mention output format, errors, or that this is a read-only operation, leaving behavior partially implicit.

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

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

Two sentences, no filler; purpose is front-loaded and the paging guidance follows immediately. Every sentence earns its place.

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

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

For a simple retrieval tool with fully documented parameters, the description covers the essential behavior and paging strategy. It does not describe the return structure, but the tool's output (source code) is largely implied by the purpose.

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 parameters. The description adds a usage hint (paging for large modules) but doesn't add meaning beyond the parameter descriptions.

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

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

The description states 'Retrieve ABAP Function Module source code' with a specific verb and resource, clearly differentiating it from sibling tools like GetFunctionGroup and GetProgram. Even though the name is generic, the description pins down exactly what is returned.

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 an explicit usage condition: for large function modules, use startLine/maxLines rather than retrieving everything at once. This is clear context, though it doesn't discuss choosing among sibling tools.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions paging but does not explain the output shape, response format, truncation behavior beyond the schema's byte-cap note, or side-effect-free nature. Most behavioral detail lives in the parameter descriptions rather than the tool description.

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

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

Two sentences with no filler: the first states the purpose, the second gives the key operational guidance. The paging instruction is front-loaded and directly actionable.

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

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

The description plus schema is adequate for paging behavior, and the required parameter is clear. However, with no output schema and no annotations, the description should give more context about what a retrieved page looks like. It also fails to flag the schema inconsistency where function_group is described as 'Name of the function module', which could confuse an agent into passing a function module name instead of a function group name.

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 descriptions already document defaults, bounds, and end-of-file behavior. The description adds a modest practical nudge about using startLine/maxLines for large function groups but does not provide meaningfully new semantic value 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 uses a specific verb and resource, 'Retrieve ABAP Function Group source code,' which clearly identifies the tool's action and object. The object is distinct enough from siblings like GetFunction, GetProgram, and GetInclude, so an agent can differentiate it without inspecting 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 a clear usage hint for large function groups: page with startLine/maxLines. However, it provides no guidance on when to choose this tool over sibling source-retrieval tools such as GetFunction or GetInclude, and no exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Retrieve' clearly indicates a read-only operation, and the pagination hint signals that large includes may need chunked access, but the description does not explicitly state behavior like byte caps, errors, or access requirements. It adds some useful context but not full behavioral disclosure.

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

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

The description is two short sentences with no filler. The first sentence names the action and resource, and the second sentence earns its place by providing pragmatic pagination guidance.

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

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

The tool is a simple retrieval operation, and the schema already documents all parameters including line behavior and hasMore semantics. The description could be slightly more complete by explicitly noting that retrieval is non-mutating, but nothing essential is missing for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description mentions startLine/maxLines operationally, but it does not add meaning beyond what the schema provides, 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 uses a specific verb ('Retrieve') and a specific resource ('ABAP Include Source Code'), so an agent knows exactly what object is fetched. It does not explicitly contrast itself with sibling tools like GetProgram or GetStructure, but the resource type is unambiguous enough to differentiate it.

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

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

The description gives actionable usage guidance: for large includes, use startLine/maxLines to page through the source instead of retrieving everything at once. It does not mention when to prefer a sibling tool, but for a fetch-source operation that is not a critical omission.

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

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

With no annotations, the description carries the full burden. It discloses that large interfaces should be paged, which hints at size-related behavior, but it doesn't state read-only intent, error cases like nonexistent interfaces, or how the source is returned. This is adequate but not rich.

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 purpose and immediately followed by the key usage tip. 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?

For a simple source-retrieval tool with three well-documented parameters, the description conveys purpose and the main operational concern. Without an output schema it could mention the return format explicitly, but the wording 'source code' makes it sufficiently clear.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the context that startLine/maxLines are for paging large interfaces, reinforcing the schema, but doesn't add meaning beyond 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?

Description uses a specific verb and resource: 'Retrieve ABAP interface source code.' This clearly distinguishes it from sibling getters targeting different object types (class, program, table, etc.) without ambiguity.

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

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

It explicitly advises using startLine/maxLines for large interfaces, giving practical pagination guidance. It does not explicitly list when not to use the tool, but the object-type scope and sibling names make the intended use clear.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that output is a serialized listing that can be large and that paging may be needed, which is useful behavioral context beyond the schema. It does not mention permissions or error behavior, but for a simple retrieval this is a reasonable level of 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?

Two sentences with no filler. The main action is front-loaded, and the second sentence adds operational guidance about paging. Every word earns its place.

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

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

The tool is simple (one required parameter, two optional paging parameters) with no output schema. The description covers the core purpose and the paging behavior. It could also state the output format more explicitly, but the schema descriptions for startLine/maxLines already cover edge cases like hasMore=false.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that startLine/maxLines are for paging large output and that the result is a listing, which supplements the schema's parameter notes.

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

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

The description states a clear verb and resource: 'Retrieve ABAP package details.' It is distinct from the many sibling 'Get*' tools by naming the specific object type. However, it does not explicitly differentiate itself from those siblings beyond the object name, and 'details' is somewhat vague.

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 usage guidance for paging ('Use startLine/maxLines to page large serialized package listings.') but does not state when to choose this tool over alternatives like GetTransaction or GetClass. The usage context is implied by the sibling structure rather than explicitly explained.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. 'Retrieve' implies a read-only operation, and the paging note signals that large responses are expected. However, it does not mention response format, error behavior, or performance considerations beyond paging, leaving some gaps.

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

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

Two sentences with no filler. The core purpose is front-loaded and the paging guidance is directly relevant to safe usage. Every sentence earns its place.

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

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

For a simple source-retrieval tool, the schema covers all parameters and the description adds paging context. There is no output schema, so return-value details are not specified, and error behavior is absent; still, the essentials needed to call it correctly are present.

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 provides 100% parameter coverage, including descriptions for program_name, startLine, and maxLines. The description adds no new parameter semantics beyond mentioning the paging parameters by name, 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 uses a specific verb and resource ('Retrieve ABAP program source code') and clearly distinguishes the tool from sibling object-specific tools like GetClass, GetTable, and GetTransaction. An agent knows exactly what this tool returns and which object type it targets.

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

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

The description gives explicit guidance for large programs: use startLine/maxLines to page instead of retrieving all at once. It does not explicitly mention alternatives among siblings, but the siblings are distinct object types, so the intended use case is reasonably clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a read operation, an environment prerequisite, and a paging strategy. However, it omits the return format and error conditions; the byte-cap and hasMore behavior live only in the schema, not the description. It adds useful context but doesn't fully cover 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 sentences with zero filler. The first sentence front-loads purpose and the version constraint; the second delivers the paging recommendation. Every clause earns its place, and the most important scoping information comes first.

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, environment, and paging but leaves out return-value shape and differentiation from closely related siblings. It is adequate but not complete; a brief note on what the returned source looks like or a pointer to GetBehaviorDefinition/GetCDSView would close the gaps.

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

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

Schema coverage is 100%, with each parameter already well documented (including hasMore=false behavior and the byte cap). The description adds only the strategic guidance to use startLine/maxLines for paging, which reinforces the parameters' purpose but introduces no new per-parameter semantics beyond the schema.

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

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

The description states a specific verb (retrieve), a precise resource (RAP Service Definition / SRVD source code), and adds a version qualifier. Among the many sibling 'Get*' tools (GetCDSView, GetBehaviorDefinition, GetFunction), the SRVD target clearly identifies what this tool returns, so an agent can distinguish it 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?

It provides practical usage guidance: the ~NW 7.54/S/4HANA prerequisite and the explicit recommendation to page through large definitions with startLine/maxLines. However, it never names alternatives or says when not to use this tool versus related getters like GetCDSView or GetBehaviorDefinition, leaving that differentiation to 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 burden of behavioral disclosure. It discloses that large structures may require paging and implies a default behavior of retrieving all lines, but it does not mention read-only guarantees, error conditions, or response format. The paging hint adds some value but is not comprehensive.

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

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

The description is two sentences with no wasted words. The purpose is stated first, followed by the key usage guidance. It is perfectly front-loaded and efficient.

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

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

For a simple retrieve tool with no output schema, the description gives the essential usage pattern (paging) and the required parameter is clear from the schema. It does not describe the return structure, but that is not critical for calling the tool correctly. The description is adequate for an agent to invoke it appropriately.

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 has 100% coverage with clear descriptions for all three parameters. The description reinforces the paging behavior but does not add new semantic detail beyond what the schema provides. It mentions the paging parameters together, but the schema already explains their meaning and defaults.

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 ('Retrieve') and resource ('ABAP Structure'), which is clear and distinguishes it from sibling tools like GetTable or GetCDSView. It does not explicitly contrast with alternatives, but the name and description make the target object type unambiguous.

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

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

The description provides explicit guidance on when to use paging (for large structures) and directs the agent to use startLine/maxLines instead of retrieving everything at once. It does not mention when to choose this tool over siblings, but the object-type specificity makes that choice obvious.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses paging behavior for large tables, which is useful, but it doesn't mention potential truncation, byte caps, or the exact return format (though the schema notes byte cap may limit lines). It also doesn't state that the operation is read-only, though that is implied. The description adds some behavioral context but not comprehensive.

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 concise sentences, zero fluff. The purpose statement is immediately followed by a targeted usage tip. Every word earns its place, and the structure is ideal for quick agent parsing.

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

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

The tool is simple (3 params, no output schema), and the description covers the core purpose and a key usage nuance. However, it does not describe what the returned structure looks like (fields, metadata, etc.) or any error behavior, which an agent might need to interpret results correctly. The absence of an output schema increases the need for a bit more detail on the return shape.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (table_name, startLine, maxLines) with their constraints and defaults. The description adds no extra meaning beyond reiterating the paging use case, which is already implied by the schema. Baseline of 3 is appropriate when the schema carries the full parameter documentation.

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

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

The description opens with a specific verb-resource pair: 'Retrieve ABAP table structure.' This clearly distinguishes the tool from siblings like GetTableContents (which returns contents) and GetStructure (which targets a generic structure), though it doesn't explicitly name them. The purpose is unambiguous and front-loaded.

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

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

The description gives explicit guidance for large tables: use startLine/maxLines to page instead of retrieving all at once. This is clear when-to-use advice. However, it doesn't mention when to choose this tool over its many siblings (e.g., GetStructure, GetTableContents), so alternative selection is left to inference.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that output is textual XML, that max_rows limits SAP rows, and that startLine/maxLines page the serialized XML when large. It does not cover errors, auth needs, or exact XML structure, but the core behavior is well communicated.

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

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

Two sentences with no filler. The main purpose is front-loaded, and the second sentence concisely explains the key parameter relationships.

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

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

Given that there is no output schema and no annotations, the description does a good job explaining the return format (textual XML) and pagination behavior. It is slightly incomplete in not addressing error cases or when the serialized size threshold triggers pagination, but the essentials for a successful call are present.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying the distinction between SAP rows (max_rows) and textual XML lines (startLine/maxLines), which would otherwise be ambiguous from the schema alone.

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

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

The description states a specific verb and resource: 'Retrieve contents of an ABAP table.' It is clear and distinguishable from sibling tools like GetTable, though it does not explicitly call out that GetTable is for metadata/definition rather than contents.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as GetTable or SearchObject. The description only explains parameter behavior, not selection criteria 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 burden of behavioral disclosure. It mentions pagination behavior and that the byte cap may return fewer lines, which is useful. However, it does not disclose the return format or whether the operation is read-only, but that is implied by 'retrieve' and the sibling set.

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

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

The description is short and to the point, with the pagination advice front-loaded. It is not verbose and every sentence adds value. It could be improved by separating the pagination hint from the main purpose, but it's still 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?

Given the tool's simplicity (3 params, all documented, no output schema), the description is adequate. It covers the main retrieval and pagination. It doesn't specify the exact structure of the response, but without an output schema, an agent might wonder what fields are returned, which is a minor 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 parameters are well-documented in the schema. The description adds a bit by explaining the purpose of startLine/maxLines for pagination, but it doesn't add much beyond that. Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves ABAP transaction details, with a specific verb and resource. It is distinguishable from sibling tools like GetProgram or GetTable, though it could more explicitly say it returns source code or metadata, but the name and description are sufficiently clear.

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

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

The description provides guidance on when to use pagination (for large results) and how to page through with startLine/maxLines. It doesn't explicitly mention when not to use this tool versus siblings, but the context is clear enough for an agent to infer it's the right tool for transactions.

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 that results can be paged and mentions a byte cap that may truncate output ('the byte cap may return fewer lines'), which is useful. However, it does not describe the structure of the returned type information or any other behavioral traits (e.g., read-only nature, potential errors). Given the tool is a retrieval, the safety profile is implicit but not explicitly disclosed. A score of 3 reflects that some behavior is covered but not exhaustive.

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

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

The description is two sentences, front-loaded with the core purpose and followed by a concise paging instruction. No redundant words. Perfectly sized for the information it conveys.

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

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

The tool has no output schema, so the description must hint at what is returned. It says 'ABAP type information' but does not elaborate on the format or content. The paging guidance is helpful, but the absence of any detail about the response structure leaves the agent guessing. Given the simplicity of the tool and the complete parameter documentation, this is a moderate gap, hence a 3.

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 have descriptions in the schema. The description adds minimal value beyond that, only reinforcing the paging use of startLine/maxLines. Since the schema already documents the parameters thoroughly, 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 clearly states the verb 'Retrieve' and the resource 'ABAP type information', which is specific enough to distinguish it from sibling tools that retrieve other object types (e.g., GetTable, GetClass). No ambiguity about what the tool does.

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

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

The description provides explicit guidance for handling large results: 'For large results, use startLine/maxLines to page through it instead of retrieving it all at once.' This is clear and actionable. It does not explicitly state when not to use this tool, but the sibling list makes it obvious that this is for ABAP types specifically, so the lack of explicit exclusion is acceptable.

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

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

With no annotations, the description carries the burden and it discloses the crucial default: 'Always dry_run: true by default', signaling that the tool does not write to SAP unless explicitly overridden. It also names the exact SAP table being modified. It stops short of describing side effects or reversibility, but the key safety behavior is covered.

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 deliver the core action first, usage context second, and a critical safety note last. No redundant filler; every sentence contributes.

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

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

The description provides the action, timing relative to a sibling, and the dry-run default. Its only notable omission is a description of the response or success signal, but the schema's dry_run field covers preview behavior and there is no output schema to explain.

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

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

Schema coverage is 100%, so the baseline is 3; both parameters are already documented in the schema. The description's mention of 'Z/Y CDS wrapper view' and the dry_run default merely echoes the schema without adding new meaning.

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

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

The description uses a specific verb ('register'), names the resource (Z/Y CDS wrapper view), the release level (C1), and the target table (ARS_RUNTIME_API_STATE). It also differentiates from the sibling CreateCDSObject by explicitly positioning this tool as the post-creation release step.

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

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

It explicitly states the temporal context 'after CreateCDSObject in P4 flow' and the goal ('so SAP's own ATC tools recognise the wrapper as released'). It does not enumerate when-not-to-use scenarios or alternative tools, but the context is clear enough to guide the agent.

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

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

With no annotations, the description carries the burden. It discloses the critical dry_run default behavior, the ability to write/activate, and the diff output. It does not mention side effects, rollback, or authorization needs, but the key safety behavior (dry-run) is clearly stated.

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 fluff. The action is front-loaded, and the critical dry-run behavior is placed prominently. Every word earns its place.

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

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

The core purpose and key behavior are covered, but the description omits any detail about the diff output format and the pagination parameters (startLine, maxLines) that are part of the schema. Since there is no output schema, the agent is left guessing what the diff looks like, and the pagination params are not integrated into the narrative.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds 'supports field name mapping' (already in schema) and reiterates the dry_run default (already in schema). It adds no new parameter-level semantics 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 opens with a specific action ('Replace a C/D CDS view reference in a Z object') and names the resource and outcome. It also distinguishes itself from the sibling read-only tools (Get*) and creation tools by focusing on modification of an existing object, making its role unambiguous.

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

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

The purpose is so specific that the intended usage is clear, but the description does not explicitly state when to use it versus alternatives (e.g., when not to use it, or prerequisites). It implicitly covers when to use it (when replacing a CDS view reference) but lacks explicit exclusions or alternative routing.

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

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

With no annotations, the description carries the transparency burden. It discloses the returned finding fields, which is useful, but it does not mention whether running ATC checks has side effects, requires specific authorizations, or can be costly/long-running.

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, the target, and the key output fields efficiently.

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

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

For a 6-parameter tool with no annotations and no output schema, this is fairly thin. The output-field list and detailed parameter schema partially compensate, but the description omits usage context, result-ordering/truncation behavior, and how it relates to sibling ATC tools.

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 including example values for object_name and supported object_type values. The tool description adds no parameter-level semantics beyond the schema.

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

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

The description names a specific action and resource: running ABAP Test Cockpit (ATC) checks on an ABAP object, and it states what is returned (priority, check name, message, source location). This clearly separates it from the metadata-getter siblings, though it does not explicitly differentiate it from closely related ATC tools like FindCleanCoreViolations.

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

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

The use case is implied: call this when ATC findings are needed for an ABAP object. There is no explicit when-to-use or when-not-to-use guidance, and no mention of which sibling to prefer for clean-core-specific or remediation workflows.

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 a real behavioral trait: startLine/maxLines page the returned textual XML, not just raw line numbers. However, it never states that the operation is read-only, how results are ordered, or what happens when no matches are found, leaving only partial disclosure.

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

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

Two short sentences with no filler. The main purpose is front-loaded, and the remaining sentence provides only the essential pagination/limit details, so every sentence earns its place.

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

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

The schema is fully documented and the description covers the key pagination/limit behavior, but for a tool with no output schema it omits usage context (when to choose this vs specific getters) and doesn't describe empty-result or error behavior. Adequate for basic invocation 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?

The input schema already documents all four parameters with descriptions, so the baseline is 3. The description adds meaningful semantics by tying startLine/maxLines to pagination of the textual XML output and clarifying that maxResults caps the number of matches, which goes slightly beyond the schema's individual parameter descriptions.

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

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

The description states a specific action ('Search') and resource ('ABAP objects'), and 'quick search' conveys a broad lookup distinct from the specific object getters listed among siblings. It doesn't explicitly name an alternative, but the verb+resource scope is unambiguous.

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

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

No guidance is given on when to use this tool versus the many specific object getters (GetProgram, GetClass, GetInterface, etc.) or any exclusions. The usage context must be inferred from the tool name and sibling list, which is not enough for an agent to reliably route its choice.

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