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

Annotations already mark the tool as non-read-only and destructive. The description adds useful side-effect boundaries: check takes 'no lock', source-only format does 'no write', and object format saves only if the object changed. This is genuinely informative beyond the annotation booleans, though it does not discuss authorization or transport-release consequences.

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 compact sentence that front-loads the three modes and their key constraints. Every clause earns its place, and there is no filler or repetition of schema fields.

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 tool with nested objects, batch activation, enhancement-spot requirements, and transport fields, the description itself is thin: it omits batch mode, the affects requirement scenario, and result/output behavior. The detailed input schema compensates for parameter semantics, but with no output schema and no guidance on expected results, the description remains only minimally 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%, so the input schema already defines parameters like object, objects, type, affects, and corr_nr. The description mostly restates mode behavior and the 'never both' constraint from the schema. It adds little new parameter-level meaning, 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 names three concrete operations with explicit verbs and targets: 'mode=check: syntax check', 'mode=activate: check then activate', and 'mode=format: pretty-print'. This makes the tool's purpose clear and specific. It does not explicitly differentiate from sibling tools like abap_write or abap_transport, so some 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?

The description gives good internal mode-selection context: check avoids locking, activate means check-then-activate, and format has distinct source/object behavior. It also includes the exclusion 'never both' for format modes. However, it never states when this tool should be preferred over sibling ABAP tools, so cross-tool usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description does add one genuinely useful behavioral fact — that a call returns a refusal and sends nothing to the SAP system — but the surrounding ABAP_ALLOW_WRITE/ABAP_MODE text is internally contradictory, which undermines rather than clarifies 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?

Only the first sentence is front-loaded and useful; the remaining three are garbled, repetitive, and self-contradictory about whether the tool is locked and whether a write flag matters. This is padding that actively confuses rather than earns its place.

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

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

For a zero-parameter tool with annotations and no output schema, the description's one job is to make the operational state clear, and it partly does (it will refuse, nothing reaches SAP). But the contradictory ABAP_ALLOW_WRITE instructions leave an agent unable to tell whether the tool is permanently disabled or can be enabled, which is exactly the ambiguity that should have been resolved.

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

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

The tool takes zero parameters (100% schema coverage), so the baseline is 4 and there is nothing for the description to compensate for. The ABAP_ALLOW_* names it mentions are server-side environment variables, not input parameters, so they add no parameter semantics either way.

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

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

The opening sentence gives a specific verb and resource: 'Run ABAP Test Cockpit static analysis on an object,' which is unambiguous on its own. However, it offers no differentiation from the many abap_* siblings (abap_test, abap_run, abap_quick_fix), and the sentences that follow muddy rather than sharpen the 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?

There is no statement of when to use this tool versus abap_test, abap_run, or abap_quick_fix, nor any prerequisite for a normal invocation. The only usage-adjacent text concerns ABAP_ALLOW_WRITE/ABAP_ALLOW_PACKAGES environment variables, and it is self-negating ('does not enable writes' followed by 'Set ABAP_ALLOW_WRITE=true'), leaving the agent unsure whether the tool can be used at all.

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

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

The readOnlyHint annotation already signals safety, and the description aligns with it ('Reads'). It adds real behavioral context beyond the annotation by labeling raw as expensive and by framing check_refs as probing up to max_sites, which warns of potential cost/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?

One tight sentence front-loads the core read operation and then uses pipe-separated modes to pack all behavior into a scannable line. Every phrase ('default', 'expensive escape hatch', 'needs object_type', 'default 25') 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 read-only tool with six fully schema-described parameters, the description covers all modes, defaults, and key prerequisites. The only gap is that search/check_refs return shapes are not described and there is no output schema to carry that burden, but invocation decision-making is 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%, so the baseline is 3, but the description adds useful semantic color: 'digest' and 'v4 XML' explain what show/raw return, and it restates mode-specific prerequisites and defaults in a compact form. This exceeds the baseline without duplicating every schema detail.

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

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

The opening verb 'Reads' plus the resource 'a BOPF business object's design-time model' makes the action and object precise. Listing the four modes (show/raw/search/check_refs) further distinguishes it from generic siblings like abap_read and abap_search.

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

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

The description gives concrete mode-selection context: show is the default digest, raw is an expensive escape hatch, search requires object_type, and check_refs is capped by max_sites. It does not explicitly state when to choose this over abap_read/abap_search, so it falls short of full exclusion 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?

Beyond the annotations, it discloses concrete behavior: the tool is LOCKED on this server and 'returns a refusal and sends nothing to the SAP system', which is exactly the kind of outcome context annotations cannot express. This is consistent with readOnlyHint=true and destructiveHint=false, though the config instructions contradict themselves ('does not enable writes' followed by 'Set ABAP_ALLOW_WRITE=true').

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, but the ordering is poor: the most decision-relevant fact (it refuses and sends nothing) is buried at the end, while the middle sentence about ABAP_MODE and ABAP_ALLOW_WRITE is confusing and self-contradictory. Front-loading the lock state would make it much tighter.

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 zero params, no output schema, and annotations covering the safety profile, the description only needs to convey behavior, which it largely does. However, the contradictory environment-variable advice leaves an agent unsure whether the lock can be lifted, so it is not fully complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description adds no parameter detail, but none is needed.

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

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

The opening sentence states a specific verb and resource ('Delete a BOPF business object'), which is enough to separate it from siblings like abap_bopf_edit and abap_bopf_test. The subsequent sentences muddy this by declaring the operation is locked, but the core purpose is still identifiable.

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 never names an alternative tool or states a when-to-use condition relative to siblings. The ABAP_ALLOW_WRITE/ABAP_MODE configuration guidance is not usage guidance for selecting this tool, and it is internally tangled, so the agent gets little help deciding when to call it.

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

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

Annotations already declare readOnlyHint/idempotentHint, so the bar is lower, but the description adds real context beyond structured fields: the server is LOCKED, the call 'returns a refusal and sends nothing to the SAP system,' and the enabling variables are named. The middle sentence is muddled ('ABAP_ALLOW_WRITE does not enable writes' immediately followed by 'Set ABAP_ALLOW_WRITE=true'), which blunts an otherwise strong 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 critical fact (LOCKED / refusal) appears in sentence two rather than being front-loaded, and the enablement sentence is self-contradictory about what ABAP_ALLOW_WRITE actually does. Four sentences deliver essentially two ideas, and the config guidance could be compressed into one clause.

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 tool with no output schema, the description covers the essentials an agent needs: what it nominally does, that this server refuses the call, that nothing reaches SAP, and how writes would be enabled. Only the confused config sentence keeps it from being fully self-sufficient.

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

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

The tool takes zero parameters, so the schema carries no semantic burden and the baseline for empty parameter sets is 4. The variables mentioned (ABAP_ALLOW_WRITE, ABAP_ALLOW_PACKAGES) are server configuration, not inputs, so there is no parameter meaning left to add.

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

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

The first sentence names a concrete verb and resource: 'Make one design-time edit to a BOPF business object, or create one,' which is far more specific than a restatement of the name. However, it never distinguishes itself from the adjacent siblings abap_bopf (read), abap_bopf_delete, or abap_bopf_test, so an agent must infer the split from names alone.

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 resource type ('design-time edit to a BOPF business object'), and the description states the precondition for actually writing (ABAP_ALLOW_WRITE=true, optional ABAP_ALLOW_PACKAGES). It gives no when-not guidance and never says why an agent would pick this over abap_enh, abap_write, or abap_bopf_delete.

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

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

Annotations cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true), and the description adds genuinely non-obvious context: the server-side lock, the ABAP_ALLOW_WRITE gate, and that a call produces a refusal with no SAP traffic. However, the headline claim of 'writing real rows' pulls against the read-only/idempotent annotations and muddies rather than clarifies the real 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 text front-loads a purpose line, then spends most of its length on environment-variable plumbing ('ABAP_ALLOW_PACKAGES is optional — it narrows the default, which is every package'), which does not earn its place for an agent that cannot set those variables. The result is dense and roundabout rather than crisp.

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 tool with no output schema the description does explain the effective outcome of a call (refusal, no SAP traffic), which is the key behavior. But it omits any sibling routing and never resolves whether the tool is meant to be invoked at all on this locked server, leaving the agent without a decision rule.

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

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

The tool takes no parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate on inputs, and it correctly avoids inventing parameters.

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

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

The opening clause 'Run a BOPF business object end to end, writing real rows' gives a verb and resource, but it is immediately undercut by the later statement that calling it 'returns a refusal and sends nothing to the SAP system,' leaving the agent unsure whether this tool writes or is a no-op. It also never differentiates itself from close siblings like abap_bopf, abap_bopf_edit, or abap_bopf_delete.

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 configuration advice (set ABAP_ALLOW_WRITE=true) rather than usage guidance — it never says when to prefer this over abap_bopf, abap_bopf_edit, or abap_bopf_delete. The one implicit steer, that the tool is LOCKED on this server, is useful but is framed as operator setup, not agent decision 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, so the description is not required to repeat those. It adds valuable context beyond annotations: 'One session at a time' and 'variables read-only, frames observe-only.' These behaviors are not inferable from annotations and help the agent understand session constraints and scope. No contradiction with annotations exists.

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

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

The description is two sentences with zero fluff. The first sentence front-loads the core actions, and the second adds key constraints. Every phrase earns its place, making it highly efficient and easy to parse.

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

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

Given the tool's complexity (13 params, nested objects, many actions) and the extremely detailed schema, the description provides a concise yet sufficient overview. It covers the main actions and crucial constraints (single session, read-only variables) without redundant repetition of schema details. It does not mention all actions (e.g., keepalive, status), but the schema handles those, so nothing critical is missing for an agent to understand the tool's role.

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 13 parameters are thoroughly documented in the input schema. The description itself does not elaborate on parameter semantics beyond listing high-level actions. Since the schema carries the full burden, the description adds no extra parameter-level meaning. 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 tool's purpose: 'ABAP debugger driver: arm breakpoints, run a program, step, inspect the stack.' It also adds distinct constraints like 'One session at a time; variables read-only, frames observe-only,' which helps differentiate it from sibling tools like abap_debug_vars or abap_debug_value that focus on variable inspection. The verb-resource pairing is specific and unambiguous.

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

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

The description does not explicitly guide the agent on when to use this tool versus its many siblings. It does not mention alternatives like abap_debug_vars for variable reading or abap_run for executing programs. While the description implies it is the central debugger controller, there is no explicit when-not-to-use or alternative routing, which is a significant gap given the tool's complexity and the large 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds 'with a row window for tables', which is also documented in the schema's 'from' and 'count' parameter descriptions. No additional behavioral context is provided, such as how paths are resolved, what happens on unknown paths (though the schema notes this), or any side effects (none due to read-only). The description adds little beyond the purpose itself, so it only slightly goes beyond the 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 sentence that front-loads the core purpose ('render one variable path in detail') and includes a key detail ('row window for tables') that informs both purpose and usage. Every word adds value; it is concise, structured, and easy to parse. There is no fluff or repetition.

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

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

For a read-only drill-in tool with all parameters documented in the schema, the description is adequate. It states the main function and a notable pagination feature. It does not describe the output format or structure, but since there is no output schema, an agent might benefit from a hint about the return shape. However, given the tool's simplicity and the schema's thorough parameter coverage, the description is sufficiently complete for correct invocation. The only minor gap is the lack of explicit return-value information.

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

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

Schema description coverage is 100%, meaning all five parameters have descriptions in the schema. The tool description itself does not elaborate on any parameter beyond what the schema provides—'row window for tables' duplicates the 'tables only' notes for 'from' and 'count'. Therefore, the description contributes no additional parameter meaning, and the baseline score of 3 applies because the schema does the heavy lifting.

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

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

The description clearly states a specific action ('render one variable path in detail') and a specific resource ('one variable path'). The term 'Tier-2 drill-in' implies this is a deeper dive following a higher-level listing, likely abap_debug_vars among the siblings. It differentiates from the sibling set by indicating a focused, single-variable operation, though it does not name an exact alternative. This is clear and moderately distinguishing, but not at the level of explicitly naming the sibling it differs from.

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 context is only implied via 'Tier-2 drill-in', which suggests it should be used after an initial variable listing (e.g., abap_debug_vars), but there is no explicit statement of when to use this tool versus alternatives, nor any exclusions or conditions. The phrase 'Tier-2' is a weak implicit signal but leaves the agent to infer the appropriate workflow. No alternative tool is named or contrasted.

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

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

Annotations already mark the tool as read-only, so safety is covered. The description adds meaningful behavioral context beyond annotations by disclosing that complex values are returned only as stubs, which is critical for an agent to know before invoking the tool.

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

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

A single sentence conveys the purpose, timing, and an important output characteristic with no filler. The key behavioral fact 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 read-only survey tool, the description covers input context via the schema, and the return behavior via the stub note. Without an output schema, it could also explain what primitive values look like or how to dereference stubs, but the sibling name abap_debug_value plus the stub statement gives enough direction for correct invocation.

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

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

Schema description coverage is 100%, so the schema fully documents stateId, scope, and filter. The description adds no parameter-level detail, but none is needed because the structured schema already carries that burden.

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 ('survey') and resource ('every variable in scope at a debugger stop'), clearly distinguishing this tool from sibling abap_debug_value, which is meant for individual value inspection. The mention of complex values returning as abap_debug_value stubs further disambiguates its role.

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 clearly scopes usage to a debugger stop, which is the essential precondition. It stops short of explicitly saying 'use abap_debug_value instead for inspecting a single value,' though that alternative is strongly implied by the stub 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?

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior, and the description adds substantial operational context: 8-day feed retention, empty list semantics, verbatim key copying, and exactly what sections or chapters return. This goes well beyond the annotations without contradicting them.

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

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

The description is dense but every sentence earns its place: purpose and scope first, followed by critical caveats, then mode/output details. It is long only because the tool's behavior is complex, and it avoids restating the tool name or echoing the schema for padding.

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, the description sufficiently explains return values, list limitations, show summary contents, and chapter section behavior. With 9 parameters and complex filtering/paging semantics, this description provides the key operational warnings an agent needs to avoid misinterpretation.

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 covers 100% of parameters with detailed descriptions, so the baseline is 3. The description adds meaningful operational nuance such as the 8-day window, the chapter-name-versus-title rule, and the warning that an empty list does not mean nothing failed. This goes beyond the schema to improve correct invocation.

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 it reads ABAP runtime errors (ST22 short dumps) from the system's dump repository, using a specific verb and resource. It also explicitly distinguishes itself from the exception text of a run this server just triggered, helping an agent avoid confusing it with run-related tools.

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

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

The description gives clear context for when to use each mode, including list versus show, and emphasizes the 8-day retention window so an empty list is not misread. It does not explicitly name sibling alternatives or state when not to use the tool, but the behavior is well-scoped.

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

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

Annotations only say readOnlyHint=false and destructiveHint=false, so the description adds that the default op writes and optionally activates. However, it does not disclose side effects of the other operations (e.g., irreversible delete, forced activation of create ops), which are only present in the schema, not the description.

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

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

Two short sentences, front-loaded with the default operation and ending with a clear pointer to the operation parameter. No waste.

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

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

For a complex 11-operation tool, the description relies heavily on the detailed schema, which covers all operations and parameter semantics. It is complete enough for selection, though it could briefly warn about destructive or always-activating operations in the description itself.

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

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

Schema coverage is 100%, so the baseline is 3 and the schema already documents all parameters. The description adds little parameter-level meaning beyond pointing to the operation parameter for the other ops.

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 ('writes'), a specific resource ('root adtcore:description'), and the exact object types (ENHO/XH, ENHO/XHH, ENHS/XS). It also explicitly differentiates from abap_write for source-body edits, so an agent can distinguish the default operation from sibling tools.

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

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

It gives an explicit when-not: 'ENHO/XHH plug-in source body: use abap_write, not this tool.' It also directs the agent to the operation parameter for the other modes, covering the intended selection path.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful context that the tool is locked and returns a refusal without contacting the SAP system, but it is internally confusing about whether setting ABAP_ALLOW_WRITE=true would enable writes. It does not contradict the annotations directly.

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 dense paragraph with ambiguous pronouns and contradictory statements about locking versus enabling writes. The key locked/refusal behavior is not front-loaded cleanly, and several clauses do not earn their place for a zero-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?

Given zero parameters, rich annotations, and no output schema, the description needs only to explain the tool's actual effect. It does say the call is refused and nothing is sent to SAP, but the contradictory deploy/run framing and unclear env-var instructions leave the agent without a coherent picture of when or why to use it.

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

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

The tool takes zero input parameters, so the baseline score is 4. The description mentions environment variables rather than input arguments, and the schema itself is empty with 100% 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 opening sentence states a specific verb and resource: 'Deploy and run small generated ABAP tools inside $ABAPSMITH_FLUID_API.' However, the subsequent claim that calling it returns a refusal and sends nothing to the SAP system conflicts with the stated deploy/run purpose, leaving the effective purpose muddled. No sibling differentiation is provided.

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 discusses environment variables such as ABAP_ALLOW_WRITE and ABAP_ALLOW_PACKAGES, but gives no clear when-to-use guidance or named alternatives among the many abap_* siblings. The instructions are further undermined by the statement that calling the tool is refused on this server.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description does add genuinely non-obvious behavior: a throwaway bridge class is deployed on every call, and on this server the call returns a refusal without touching SAP. Those additions are valuable, but the middle sentences about ABAP_ALLOW_WRITE/ABAP_MODE are self-contradictory and reduce trust in the rest.

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?

Purpose is front-loaded, which is good, but the body is rambling and internally contradictory ("ABAP_ALLOW_WRITE does not enable writes" followed by "Set ABAP_ALLOW_WRITE=true"). Sentences do not earn their place; the lock explanation could be one clear line.

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

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

For a zero-parameter, no-output-schema tool the definition is nearly complete: it explains that the call returns a refusal and sends nothing to SAP, which is the key operational fact. But the garbled lock/env-variable narrative leaves an agent unsure whether the tool can be invoked at all, and no sibling alternative is named.

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 are zero parameters, so the schema is complete by default (baseline 4). However, the description introduces ABAP_ALLOW_WRITE and ABAP_ALLOW_PACKAGES in an imperative tone ("Set ...=true") that could be mistaken for invocation parameters rather than server environment configuration. That ambiguity costs a point.

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

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

The opening clause gives a specific verb and resource: "Read SAP FPM/FBI screen configurations." That is enough to distinguish it from generic siblings like abap_read or abap_search. However, the remaining four sentences are consumed by lock-state and environment-variable talk that obscures rather than sharpens the purpose.

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

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

The description does signal that the tool is LOCKED and that "Calling it returns a refusal and sends nothing to the SAP system," which is a when-not-to-use hint. But it immediately undercuts itself with "Set ABAP_ALLOW_WRITE=true," leaving the agent unable to tell whether the tool is usable. No alternatives or routing guidance to siblings 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?

Annotations already mark readOnlyHint and openWorldHint, but the description adds substantial behavioral details: paging via opaque cursor with no numeric offset, exact cursor format to pass back, default/ceiling limits, and mode-specific field rejection. This goes well beyond the structured 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 compact and front-loaded, starting with the overall purpose, then briefly enumerating modes and key constraints. Every sentence contributes; the paging and validation rules are stated succinctly without 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 tool with 10 parameters and 4 modes, the description covers all modes, parameter applicability, paging, and validation. It does not detail response structures or error behavior, but given the read-only annotations and the lack of an output schema, the core call semantics are complete enough.

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?

Beyond the 100% schema coverage, the description maps each parameter to its mode (query→search, activity→show, node/treeId→tree, object/kind→objects) and explains paging semantics, wildcard behavior, language key format, and field rejection rules—all adding meaning not obvious 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 clearly states 'Read the IMG customizing catalog' and enumerates four distinct modes (search/show/tree/objects), each with a specific verb and resource. It differentiates from sibling abap_img_edit, which presumably modifies the catalog, making the read-only purpose 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 explains what each mode does and which parameters apply to which mode, giving clear context for selecting the right mode. However, it does not explicitly mention when to prefer this tool over siblings like abap_img_edit or abap_read, nor does it provide when-not-to-use guidance.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, which the description contradicts by claiming the tool writes rows. The description also asserts the tool is 'LOCKED' and 'returns a refusal,' which is a behavioral claim, but it muddles rather than clarifies the safety profile. It does disclose the configuration variable as the deciding factor, which is one useful nugget, but the core behavioral claim conflicts with the structured metadata.

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 first sentence is reasonable, but the rest of a five-sentence passage is spent unpacking one environment variable. The parenthetical about ABAP_ALLOW_PACKAGES is rambling and contains meta-commentary about defaults. The structure buries the operational instruction (set a flag to unlock) inside explanatory noise.

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 tool with annotations, the description should be crisp. Instead, it is incomplete because it never clearly states the tool's effect when unlocked, nor why it would be preferable to abap_img. It provides a postcondition ('returns a refusal and sends nothing') only for the locked state, omitting the primary behavior.

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

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

With 0 parameters in the schema, the baseline is 4. The description does not invent nonexistent parameters, and the mention of ABAP_ALLOW_WRITE is environment configuration rather than tool input. However, the description never states that this tool takes no parameters, which could confuse an agent and is a missed opportunity.

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 'Preview and write IMG/customizing table rows,' which gestures at a purpose, but it immediately abandons that to discuss configuration flags. It pairs 'preview' and 'write' as a single verb phrase, which is confusing, and it never states what the tool actually does when it's not refusing. It sits next to abap_img, abap_bopf_edit, and abap_write without explaining 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?

The description explains the environmental precondition (ABAP_ALLOW_WRITE=true) but does not say when an agent should prefer this over abap_img or abap_write, which are the obvious siblings. There is no 'when to use' or 'when not to use' guidance beyond the lock state. The reader learns that it will refuse, but not what the intended use case is.

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 only destructiveHint=true and readOnlyHint=false in annotations, the description carries the behavioral burden and handles it well: undo refuses on drift, delete-gate, or enhancement objects; force overwrites concurrent changes; reconcile sends nothing to SAP. These details meaningfully extend the annotations without contradicting them.

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

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

The description is compact and front-loaded: purpose, parameter inventory, then four parenthetical call patterns. It stays dense but readable, and every clause contributes either mode semantics, a safety caveat, or a routing hint.

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 10-parameter, four-mode tool with no output schema, the description covers mode behavior, parameter interactions, safety gates, and the special reconcile non-SAP behavior. It is slightly thin on exact return formatting or error conventions, but provides enough context to invoke the tool correctly in most situations.

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 showing parameter combinations for each mode and by adding safety semantics not fully stated in schema descriptions, such as the reconcile bookkeeping-only guarantee and the undo refusal conditions.

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 pairing: 'History and undo for writes abapsmith made.' It names the four modes (list, show, undo, reconcile) and provides concrete common-call examples, which clearly distinguishes it from sibling tools like abap_write or abap_transport.

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 common-call patterns give practical guidance for when to use each mode, and the reconcile note explicitly scopes that mode to journal bookkeeping only. However, it never names an alternative tool or states a when-not-to-use condition, leaving the tool-selection decision largely implicit.

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

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

Annotations already mark this as read-only and open-world safe. The description adds useful behavioral context beyond annotations: it will not actually open a browser, and it requires exactly one of the mutually exclusive modes. No contradiction with the annotations exists.

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

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

The description is compact and front-loaded: it states the output, lists the input modes, then gives the two most important caveats in short sentences. Every sentence earns its place and nothing is 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 simple URL-generation tool with read-only annotations, the description is mostly sufficient: it defines what the URL is for, which parameter to use, and the key side-effect note. It could go slightly further by specifying the shape of the returned URL or error behavior for invalid combinations, but the title and schema fill in most 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%, so the baseline is 3. The description adds extra meaning by grouping the parameters into ADT source/HTML (object/type/line), keyword doc (keyword), and Web Dynpro URL (webdynpro), and by clarifying that exactly one is required even though the schema lists no required 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 clearly identifies the deliverable as a browser-openable URL and enumerates the three supported input modes (ADT source/HTML, keyword doc, Web Dynpro URL). The explicit note 'Does not open a browser' prevents a likely misinterpretation and distinguishes this tool from read/search-type siblings.

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

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

The phrase 'Exactly one required' gives a clear usage constraint, and 'Does not open a browser' tells the agent what the tool will not do. However, it does not explicitly name sibling alternatives or state exactly when to prefer this tool over another, so usage guidance is strong but not fully 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds genuinely new behavior: the tool is locked on this server and calling it returns a refusal without sending anything to SAP. However, the surrounding logic is garbled ('ABAP_ALLOW_WRITE does not enable writes... so that variable is what decides it', then 'Set ABAP_ALLOW_WRITE=true'), which muddies an otherwise useful 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 useful purpose sentence is followed by three sentences of dense, self-contradictory server-config text about environment variables. That material does not earn its place for an agent selecting a tool, and the structure front-loads a purpose it then undermines.

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 tool with no output schema, the description never explains how a quick fix is identified or what listing returns. Combined with the missing position parameter and the muddled lock explanation, an agent cannot tell what would actually happen or how to invoke it meaningfully.

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

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

With zero parameters and 100% schema coverage, the baseline is 4. The description is downgraded because it references configuration knobs (ABAP_ALLOW_WRITE, ABAP_ALLOW_PACKAGES) and a 'source position' that appear nowhere in the empty schema, so it does not clarify the actual (absent) inputs and instead introduces entities the agent cannot supply.

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

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

The first sentence gives a verb and resource: 'List and apply ADT quick fixes at one source position.' But the scope phrase 'at one source position' is unactionable given the schema has zero parameters, and nothing distinguishes this from siblings like abap_write, abap_enh, or abap_read. The purpose is stated but immediately buried under server-config discussion.

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 relative to alternatives, nor any exclusions. The only guidance is operational server state ('LOCKED on this server... calling it returns a refusal'), which tells the agent the tool is inert but not when to prefer this over any sibling.

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

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

The description is consistent with the readOnlyHint annotation and reinforces it by calling the catalog render 'read-only'. It adds valuable non-obvious behavior beyond annotations: large class/source objects default to an outline, method= reports foundOn for inherited members, responses carry an etag, are capped around 15k tokens, and mark truncation. No contradiction with annotations is present.

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

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

The description is dense but every sentence contributes: scope, default outline behavior, signature guidance, result-size cap, truncation marking, and an example. It is a single long paragraph rather than structured bullets, but for 21 parameters it remains efficient and front-loads the core read operation before explaining mode variants.

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 21 parameters and no output schema, the description covers the main invocation modes, the default outline threshold, parameter combinations, result-size limits, and an example. It does not fully enumerate every possible response shape for views like diff, docu, or digest, but the schema provides 100% parameter coverage, and the description supplies enough behavioral context for safe invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by showing how parameters combine: method= with include="definitions", pattern= with context and offset/limit, and full=true to override the outline default. The concrete example {'object':'ZCL_FOO','type':'CLAS/OC'} also helps agents understand how object and type interact.

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 'Read an ABAP object' and then enumerates concrete read targets: source, pseudo-DDL, DEVC/K package listing, and read-only catalog renders for SUSO/B and TABL/DI. This is a specific verb+resource mapping, and the explicit 'read-only' wording distinguishes it from write/edit siblings like abap_write and abap_edit.

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 mode-level guidance: use method= with include="definitions" for a method signature, pattern= for grep-like matching, and full=true to bypass the default outline threshold. It does not explicitly name alternative sibling tools or say when to prefer abap_search over abap_read, but the major when-to-use cases within this tool are clearly specified.

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

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

The lock details ('ABAP_ALLOW_WRITE does not enable writes, ABAP_MODE decides it', 'calling it returns a refusal and sends nothing to the SAP system') add genuine context beyond the readOnlyHint/idempotentHint annotations. However, it's odd that a run tool is readOnly while describing write-enabling variables, creating some conceptual friction though not a direct contradiction.

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

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

Four sentences, three of which are about a server-side lock rather than the tool. The most important fact (it executes ABAP) is front-loaded but then the lock details dominate, and the 'so that variable is what decides it' phrasing is confusing and referent-ambiguous.

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-param, no-output-schema tool, the core purpose and lock behavior are covered. But the description gives no info on output format, error behavior when unlocked, or how the agent should actually proceed given the lock – leaving a practical 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?

Zero parameters, so baseline 4 applies. The description correctly notes there are no inputs to configure, though it names environment variables that aren't schema parameters.

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

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

It states a specific action ('execute an IF_OO_ADT_CLASSRUN class or report and capture its output'), which is clearer than a bare name. But the sentence is immediately buried under lock/refusal text, and it never distinguishes itself from siblings like abap_write or abap_read.

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 and no alternative routing; the only condition given ('set ABAP_ALLOW_WRITE=true') is a lock that the tool itself refuses. The agent is told it will be refused but not how to actually run ABAP through this server.

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?

Besides the readOnlyHint/openWorldHint annotations, the description discloses meaningful behavioral details: where_used can take 20+ seconds on wide fan-in, source mode requires the fluid API, and hits are grouped per object. It also surfaces the depth<=4 constraint and wildcard 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 a single dense sentence with no filler, packing each mode's purpose and key caveats into one readable block. It is efficient, though the long parenthetical chain is somewhat heavy; still well-structured for a tool with this many parameters.

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

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

Given the rich schema, annotations, and full parameter coverage, the description covers mode selection, output grouping, prerequisites, and performance expectations. It doesn't detail return structures beyond grouping, and no output schema exists to fill that gap, but the core decisions for invoking the tool are covered.

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 13 parameters. The description restates key mode semantics and adds a few behavioral hints like depth<=4 and package/objects scope, but it does not materially deepen parameter meaning 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 names four distinct operations — searching objects by name pattern, listing where-used consumers, walking call graphs, and scanning source text — each tied to a specific mode value. This clearly differentiates abap_search from read and lookup siblings like abap_read.

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 mode-level usage guidance, such as narrowing by type/query for where_used and requiring the fluid API plus a scope for source scans. It doesn't explicitly contrast abap_search with sibling tools, but the conditions for selecting each mode are 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?

Annotations already flag non-read-only and destructive behavior. The description adds valuable context beyond that: publish/unpublish register/deregister the binding in the OData runtime, require confirm and admin-mode ceiling, and unpublished bindings are named as such. It also notes V2/V4 detection. This provides behavioral nuance the annotations do not convey, with no contradictions.

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

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

The description is three dense sentences with no filler. The main purpose is front-loaded ('OData contract a RAP SRVB publishes'), followed by a key limitation, then side-effect conditions. Every clause earns its place, and the telegraphed style is information-dense without being bloated.

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 five parameters, two enums, and no output schema, the description sufficiently covers the tool's scope, limitations, and operational prerequisites. It explains what the contract includes, what it cannot do, and the publish/unpublish workflow. The schema fills in parameter details, so nothing critical for correct invocation 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 coverage is 100% with thorough per-parameter descriptions. The description echoes the op behavior ('op="publish"/"unpublish"') but does not add new parameter-specific meaning beyond what the schema already states. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'OData contract a RAP SRVB publishes' and enumerates what the contract contains (entity sets, keys, fields, nav, perms). It clearly distinguishes itself from data-reading tools with 'Cannot read entity data — contract only' and explicitly names its ops (publish/unpublish). This makes its purpose unmistakable among the many abap_* siblings.

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

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

It gives clear context for when to use publish/unpublish: 'admin-mode ceiling, confirm required to arm' and 'off unless ABAP_ALLOW_SERVICE_PUBLISH permits it.' It also states an explicit when-not: 'Cannot read entity data — contract only.' However, it does not name an alternative sibling tool (e.g., abap_read) for data reads, so it lacks explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds a confusing claim that the tool is 'LOCKED,' that calling it 'returns a refusal,' and that no request is sent — which reads as behavior but contradicts the stated purpose of running tests, and gives no coherent account of what actually happens.

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 useful purpose statement is front-loaded, but it is followed by several garbled sentences about ABAP_ALLOW_WRITE, ABAP_MODE and package scoping that do not clearly resolve into a single actionable meaning. Sentences like 'that variable is what decides it' have no clear antecedent, so the length is not earning its place.

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

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

There is no output schema, so the description should explain what running tests returns; instead it says the call is refused, which leaves the agent unable to know the actual outcome. For a zero-param tool with rich annotations, the description needed to clarify invocation behavior and it does the opposite.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Schema coverage is reported at 100% with no properties to document, and the description introduces no parameter concepts beyond environment variables that are not inputs.

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

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

The opening sentence names a specific verb and resource ('Run ABAP Unit tests and report each method's verdict'), which is clear enough. But the remainder muddles it badly: it claims calling the tool 'returns a refusal and sends nothing to the SAP system,' leaving the agent unsure whether the tool actually runs anything. It also doesn't distinguish this from siblings like abap_bopf_test or abap_atc.

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 references config variables (ABAP_ALLOW_WRITE, ABAP_ALLOW_PACKAGES, ABAP_MODE) but never states when to use this tool versus alternatives such as abap_bopf_test or abap_run. The 'guidance' is about environment toggles, not about tool selection or preconditions an agent can act on.

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

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

Annotations already flag this as destructive (destructiveHint=true) and not read-only, and the description adds meaningful behavior: op=delete removes runs/requests, op=start arms a request, and op=run traces and reads back results. It covers the key side effects beyond what the annotations alone state.

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

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

The description is compact, information-dense, and front-loaded: it states the core purpose first, then cleanly maps each operation to its effect. There is no filler, and 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?

Given the tool's complexity (5 operations, 18 parameters, no output schema), the description covers the operation semantics well and even notes defaults like op=run. It does not describe the exact shape of results or prerequisites beyond what the schema already provides, but for selecting and invoking the tool it is largely 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%, so the baseline is 3. The description enriches the op parameter by explaining what each operation does, but it does not add meaning for the many other parameters, which are already well-documented in the input 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 opens with a specific resource, ABAP runtime tracing (SAT), and a clear action: recording time per call and database access for a request's dispatch. It then enumerates each operation (run, start, list, read, delete) with concrete effects, making the tool's purpose obvious and distinguishing it from generic ABAP read/run/debug siblings.

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

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

The description gives clear within-tool guidance for choosing among operations, such as using op=start to arm a later trace versus op=run to trace immediately. However, it does not address when to choose abap_trace over sibling tools like abap_run, abap_debug, or abap_test, nor does it state exclusions or alternatives.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=true), the description discloses concrete behavioral constraints: which operations are always allowed, which need write access, and that delete/removeObject require confirm plus the admin-only ceiling. This is exactly the type of operational context an agent needs to invoke safely.

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

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

The description is dense but every clause carries necessary information: operation list, access levels, required arguments, and a pointer to deeper docs. It could be broken into sections for readability, but given the tool's complexity, the single-paragraph format is still efficient and front-loaded with the core purpose.

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

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

For a multi-operation tool with 11 parameters, no output schema, and destructive operations, the description covers the essential execution context: operations, permissions, required arguments, confirm flow, and where to find detailed semantics. Nothing an agent needs to call it correctly is missing.

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

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

The input schema already covers 100% of parameters with descriptions, but the tool description adds operation-to-parameter mapping (e.g., 'delete transport+confirm', 'create package+description') and clarifies defaults like kind='workbench' and why copies require target. This adds meaning beyond the schema without duplicating 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 opens with 'Inspect and manage CTS transport requests' and then lists the full operation set, giving a specific verb and resource. It explicitly distinguishes release as a separate tool, so an agent can tell this apart from abap_transport_release without opening either 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 provides explicit when-to-use guidance by categorizing operations as plain reads versus write/delete operations, and details the exact permission ceilings (write access, admin-only transport-delete ceiling) and required arguments per operation. It also names the sibling tool for release, making the routing decision unambiguous.

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

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

The description adds genuinely useful behavioral context beyond the annotations: the tool is locked on this server, will return a refusal, and sends nothing to SAP. But this collides with the annotations, which declare readOnlyHint=true and destructiveHint=false while the description headlines the operation as an irreversible release — so the safety profile an agent reads from structured data conflicts with the stated nature of the action.

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 purpose is front-loaded, but the middle of the description is near-duplicated boilerplate: two consecutive sentences with identical structure explaining that an env var does not enable the action and that ABAP_MODE is unset and "decides it." The repetition wastes space and makes the actual gating logic harder to parse.

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

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

For a zero-parameter tool with no output schema, the description covers the critical fact that the tool is disabled and will refuse. It nonetheless leaves the agent unsure what the call returns when the gates are enabled, and the contradictory framing of the action's safety leaves the operational picture incomplete.

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 zero parameters, so the baseline is 4 and there is nothing for the description to disambiguate. The env-var names it mentions (ABAP_ALLOW_WRITE, ABAP_ALLOW_TRANSPORT_RELEASE, ABAP_ALLOW_PACKAGES) are server configuration, not call parameters, so they add no parameter semantics.

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

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

The opening sentence gives a specific verb and resource — "Release one CTS transport request — irreversible" — which clearly separates it from siblings like abap_transport or abap_write. The remainder of the description muddies this by explaining that the operation is actually locked out, but the nominal purpose is unambiguous.

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

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

The description does convey the gating condition for use (ABAP_ALLOW_WRITE=true and ABAP_ALLOW_TRANSPORT_RELEASE=true plus ABAP_MODE) and warns that calling it as-is yields a refusal. However, it never states when an agent should prefer this over the sibling abap_transport, nor what the agent should do instead in the locked state.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds genuinely new context ('LOCKED on this server', 'returns a refusal and sends nothing to the SAP system'), but it is internally confusing and self-contradictory — it first says ABAP_ALLOW_WRITE does not enable writes, then instructs 'Set ABAP_ALLOW_WRITE=true' — so the added value is diluted.

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 first sentence is well front-loaded, but the remaining env-var sentences are jumbled, repetitive, and self-contradictory ('ABAP_ALLOW_WRITE does not enable writes' vs 'Set ABAP_ALLOW_WRITE=true'). They consume space without conveying a coherent, actionable instruction.

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

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

For a parameterless tool with no output schema the bar is low, and the description does convey that the tool is locked and returns nothing. However, the muddled env-var discussion leaves the agent unclear about whether the tool does anything at all, and it never explains the two stated modes (read screen vs run transaction) under the locked state.

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

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

The tool takes zero parameters, and schema coverage is 100%, so there is no parameter semantics for the description to carry. Baseline of 4 for a parameterless tool 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 opening sentence gives a specific verb and resource ('Drive classic SAP dynpro screens via batch input') plus the two modes ('read one screen, or run a scripted transaction'), which lets an agent distinguish it from siblings like abap_read or abap_run. It is somewhat muddied by the subsequent environment-variable paragraph, but the core purpose is stated clearly.

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 explicit guidance on when to choose this over sibling tools such as abap_read, abap_run, or abap_fluid. The only usage-relevant statement is that calls are refused on this server, which is a behavioral caveat rather than directional guidance.

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

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

The description claims create/change/delete operations, but annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, directly contradicting a mutating tool. This is a serious annotation contradiction. The lock/refusal information is useful behavioral context, but the fundamental contradiction dominates.

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 somewhat rambling and mixes lock semantics, environment variables, and refusal behavior in a run-on fashion. The core purpose is front-loaded, but the middle sentences are difficult to parse and could be tighter.

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 zero-parameter schema and no output schema, the description should clarify the write contract (what gets created/changed/deleted, required state). Instead it focuses on a lock state and contradictory operation claims, leaving the actual write behavior under-specified and inconsistent with annotations.

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

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

There are zero parameters, so the baseline is 4. The description mentions environment variables (ABAP_ALLOW_WRITE, ABAP_ALLOW_PACKAGES, ABAP_MODE) that affect behavior, which adds meaning beyond the empty schema, though these are not tool parameters.

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

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

The description states a specific verb set (create, change, delete) and resource (ABAP object), and mentions save/check/activate phases. It distinguishes the tool from read-oriented siblings like abap_read or abap_search, though it does not explicitly name alternatives.

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

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

It implies usage for writing ABAP objects but provides no explicit when-to-use vs when-not-to-use guidance or comparison to siblings like abap_activate or abap_enh. The lock condition is described, which is a form of conditional availability, but usage context for the write itself is thin.

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