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

Without annotations, the description carries the full burden and discloses key behaviors such as sampling up to 10,000 records, default sample size 1,000, support for numeric/string/date columns, and automatic type detection. It does not mention side effects because it is a read-only analysis, but the disclosed operational traits are sufficient for informed use.

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

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

The description is well-structured with sections, but it is lengthy and contains redundancy: 'What you'll get' and 'Analysis includes' overlap, and use cases repeat the 'Use this tool when' content. It could be trimmed significantly without losing value.

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

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

Given the absence of an output schema, the description compensates effectively with a 'What you'll get' section that outlines return information, plus performance notes and examples. It covers all essential aspects—purpose, usage, behavior, and parameters—making it complete for an AI agent.

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

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

Schema coverage is 100% with detailed descriptions for all parameters, including defaults and bounds (e.g., sample_size min/max, include_outliers default). The description adds little beyond the schema; the 'Performance notes' mostly echo parameter constraints, so the baseline 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 explicitly states 'Perform advanced statistical analysis of a column's data distribution including nulls, distinct values, percentiles, and outlier detection.' This uses a specific verb and resource, and clearly differentiates from siblings like get_table_schema or execute_query by focusing on distribution profiling and statistics.

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

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

Provides an explicit 'Use this tool when' list and multiple example queries, giving clear context for when to deploy this tool. However, it does not explicitly state when not to use it or name alternative tools, so it falls short of a 5.

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

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

Since no annotations are provided, the description carries the full burden. It discloses the read-only nature implicitly through 'Browse and search' and details the expected output fields (package IDs, names, descriptions, categories, provider info, versions, sizes, pricing). It does not mention side effects, authentication requirements, or limitations, but for a non-mutating marketplace browse tool, this is acceptable and adds meaningful context.

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

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

The description is well-structured with clear sections (when to use, what you'll get, categories, examples, use cases). It is front-loaded with the main purpose, and every section provides actionable information. There is no filler or redundant content.

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

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

Although the tool is simple (2 optional params, no output schema), the description is comprehensive. It explains the tool's scope, typical use cases, example queries, and the structure of returned data. For an AI agent, it provides enough context to decide when and how to invoke the tool without additional 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?

The input schema already documents both parameters with descriptions, and schema coverage is 100%. The description adds value beyond the schema by supplying example queries and categories that clarify how to use the filters (e.g., 'currency' or 'benchmark' for search_term). This helps the agent map natural language to parameter values.

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 with a specific verb and resource: 'Browse and search available data packages in the SAP Datasphere marketplace.' It is distinctly different from sibling tools, which focus on connections, tables, queries, and administrative operations. The description also enumerates the types of data returned, further reinforcing its unique 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 includes an explicit 'Use this tool when:' section with concrete scenarios (e.g., 'What data packages are available?', 'Looking for external reference data'). It also provides example queries and use cases. However, it does not explicitly mention when not to use the tool or any sibling alternatives, so it stops short of full guidance.

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

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

No annotations are provided, so the description carries the full burden. It explicitly flags the tool as HIGH-RISK, requires user consent, states that passwords are auto-generated and shown once, and includes security notes about retention and privilege principles. This goes beyond a typical create operation.

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

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

The description is long but well-structured with headings, bullet lists, a JSON example, and a CLI mapping. The high-risk warning is front-loaded, and every section adds practical value for such a complex 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 the complex nested parameters, absence of output schema, and high-risk nature, the description is remarkably complete. It covers return behavior ('password is auto-generated and returned'), parameter details, security warnings, usage examples, and even a CLI equivalent.

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%, but the description adds substantial meaning: it explains the nested user_definition structure in detail, clarifies that database_user_id is a suffix prefixed with space name, and recommends output_file for credential safety. This far exceeds the schema descriptions.

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

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

The description opens with a specific verb+resource: 'Create a new database user in a SAP Datasphere space with specified permissions.' It clearly distinguishes this from sibling tools like list_database_users, update_database_user, and delete_database_user by focusing on creation.

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

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

The description provides explicit 'Use this tool when' bullets and example queries, making the intended use clear. It does not include when-not-to-use or alternative tool recommendations, but the context is strong enough for selection.

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

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

With no annotations provided, the description takes full responsibility for disclosing behavioral traits. It explicitly states the action is IRREVERSIBLE, permanently deletes the user, terminates all active sessions, revokes all privileges, and logs the deletion for audit. It also warns about potential errors if the user owns objects, going well beyond what annotations could convey.

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

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

Although the description is long, it is highly structured with sections (IMPORTANT, WARNING, Use this tool when, What happens, Required parameters, Safety considerations, Before deleting, Example queries, Best practices, Note). Each section earns its place by addressing a distinct concern—risk, use cases, effects, parameters, safety, procedure, examples, best practices, and CLI mapping. No fluff.

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 high-risk nature, absence of annotations, and lack of output schema, the description leaves nothing to guesswork. It covers the action, consequences, prerequisites, safety checks, step-by-step pre-deletion actions, example queries, and even a CLI equivalent. The tool is fully contextualized within its environment, making it safe for an agent to act on.

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 each parameter clearly. The description adds value by grouping them under 'Required parameters,' clarifying the force flag as optional, providing example queries that map to parameter values, and noting the uppercase requirement for space_id. While not dramatically expanding on the schema, it reinforces practical usage.

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

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

The description clearly states 'Delete a database user from a SAP Datasphere space' with a specific verb and resource, and it distinguishes itself from sibling tools like create_database_user, update_database_user, and reset_database_user_password by focusing solely on deletion. The explicit 'Use this tool when' list reinforces its unique 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 provides explicit when-to-use scenarios (e.g., 'User explicitly requests...', 'Decommissioning user accounts') and a detailed 'Before deleting' checklist that includes verifying dependencies and getting approvals. It also suggests an alternative ('Consider deactivating instead of deleting') and references sibling tools like list_database_users for pre-checks, making usage boundaries crystal 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?

No annotations are provided, so the description carries full burden. It discloses critical behaviors: read-only access, blocked operations (INSERT, UPDATE, etc.), no SQL comments, query sanitization, user consent requirement, default row limit, and mock-data/OAuth notes. It even labels itself 'HIGH-RISK', providing strong transparency.

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

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

The description is well-structured with headers, bullet points, and front-loaded purpose and risk warnings. It is verbose and contains some redundancy (e.g., 'no write operations' repeated, 'user consent' mentioned twice), but each section adds useful information. Slightly over-long but organized enough to earn a 4.

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 complexity (SQL execution, security restrictions), the description covers use cases, capabilities, security rules, best practices, examples, error handling, and environment-specific notes. However, with no output schema, it does not explicitly describe the exact response format (e.g., array of objects), leaving a minor gap in completeness.

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

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

All three parameters have rich descriptions in the input schema, covering defaults, ranges, case requirements, and syntax examples. The tool description adds examples and best practices but does not introduce new parameter semantics beyond what the schema already provides. Baseline of 3 is appropriate due to 100% schema coverage.

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

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

The description opens with a specific verb and resource: 'Execute read-only SQL queries against SAP Datasphere tables to retrieve and analyze data.' It clearly states the tool's purpose and scope (read-only SQL on tables), distinguishing it from siblings like query_analytical_data or query_relational_entity. Examples further reinforce the SELECT-only nature.

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 includes a dedicated 'Use this tool when:' section with explicit scenarios (data retrieval, aggregations, joins, filtering). It also suggests checking table schema with get_table_schema() and mentions using search_tables() for missing tables. However, it does not explicitly name alternative tools or provide 'when not to use' exclusions, which prevents a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful details such as multi-space search by default, intelligent caching, a configurable 50-asset limit, and case-insensitive search. While it doesn't cover error handling or pagination, it gives a solid behavioral picture beyond the basic function.

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

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

The description is well-structured with clear sections (overview, when to use, expected results, use cases, examples, performance notes). It is somewhat long but each section adds value and the core purpose is front-loaded. No wasted sentences, but it could be slightly more concise without losing substance.

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 search tool with no output schema and no annotations, this description is remarkably complete. It explicitly lists what the user will get (asset names, types, space IDs, column info, URLs), covers a wide range of use cases and example queries, and even notes performance characteristics. This fully compensates for the missing structured metadata.

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

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

The input schema descriptions already cover 100% of parameters, so the baseline is 3. The tool description reinforces parameter usage through example queries but does not add significant semantic meaning beyond what the schema already provides. It correctly mentions default behaviors like case-insensitivity and the 50-asset limit, which appear in schema defaults.

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

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

The description uses a specific verb+resource+scope: 'Find all assets (tables/views) containing a specific column name across SAP Datasphere spaces.' This clearly distinguishes it from siblings like search_tables or get_table_schema, and the detailed use cases reinforce the tool's specialty in column-based discovery.

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 'Use this tool when' bullets and multiple use cases, giving clear context for when to invoke it. However, it does not explicitly name alternative tools or state 'when not to use' this tool, so it stops short of a perfect score.

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

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

With no annotations provided, the description is the only source of behavioral information. It discloses the automatic identification of analytical elements via SAP annotations and outlines the returned schema components. However, it does not mention any side effects, prerequisites, permission requirements, or failure behavior. For a read-only metadata retrieval, this is adequate but not comprehensive.

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

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

The description is three concise sentences, immediately states the action and resource, and adds relevant detail about return content and behavior without fluff.

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

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

The description adequately covers the tool's purpose, return content, and a key behavior for a metadata retrieval tool. Without an output schema, it does enough to set expectations about dimensions, measures, hierarchies, and aggregation. However, it lacks information about the exact CSDL format or how missing annotations are handled, which could be useful but is not critical.

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

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

Schema description coverage is 100%, so the baseline is 3. The description indirectly relates to the identify_dimensions_measures parameter by mentioning automatic identification, but does not provide explicit parameter-level guidance beyond the schema. The main parameters space_id and asset_id are only described in the schema, not elaborated further in the description.

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

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

The description uses the specific verb 'Retrieve' and clearly identifies the resource as 'CSDL metadata for analytical consumption of a specific asset.' It distinguishes itself from sibling tools like get_relational_metadata by explicitly specifying analytical metadata, and mentions the return schema content.

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

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

The description provides clear context that this tool is for analytical and BI integration needs, but does not explicitly name alternatives or exclusion criteria. The context signals show several sibling metadata tools, but the description relies on the term 'analytical' to differentiate.

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

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

No annotations provided, so description carries full burden. It explains return content and parsing logic (CSDL, annotations, fallback), but omits side effects, authentication requirements, or error handling. Adequate but not comprehensive.

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

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

Two sentences, no redundancy. First sentence states purpose and output, second sentence provides technical detail. Every word serves a purpose.

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

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

Given no output schema and no annotations, the description adequately explains the tool's return content (dimensions, measures, entity sets) and parsing methodology. Lacks output format specifics and error scenarios, but sufficient for a retrieval tool.

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

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

Schema covers 100% of parameters with descriptions. The description adds technical context about returned metadata and parsing approach but does not elaborate on parameter syntax or constraints beyond the schema. 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 it retrieves the OData service document and metadata for a specific analytical model, listing key components (entity sets, dimensions, measures, query capabilities). It distinguishes itself from siblings by focusing on a single model's metadata with parsing details.

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

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

No guidance on when to use this tool versus alternatives like get_analytical_metadata or list_analytical_datasets. Lacks context on prerequisites, exclusions, or typical use cases.

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

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

With no annotations, the description carries the full burden. It explains the compound-key mechanism, the API endpoint, and the comprehensive return content (dimensions, measures, relationships, technical/business context). This is robust disclosure for a read-only retrieval operation, exceeding the typical vague 'retrieves data'.

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

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

The description is longer than typical but well-structured with headings and bullet lists, and front-loaded with a concise summary sentence. Every section serves a clear purpose, though some repetition exists (e.g., 'same metadata as get_asset_details' appears twice in different forms).

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

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

For a two-parameter retrieval tool with no output schema, the description is exceptionally complete. It covers use cases, parameters with examples, behavior, endpoint, and comparison with sibling tools, leaving little ambiguity for an agent to select and invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds substantial meaning: it explains how space_id and asset_id combine into the OData compound key, provides a concrete format example, and includes example queries. This enriches the parameter understanding beyond the schema's simple field types.

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

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

Clearly states 'Retrieve asset using OData compound key identifier' with a specific verb and resource, and immediately distinguishes it as an 'alternative access method' relative to get_asset_details. The title 'null' is compensated by a dense first sentence that precisely defines the tool's unique function.

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

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

Provides explicit bulleted 'Use this tool when' criteria and a dedicated 'When to use this vs get_asset_details' section, listing both scenarios and alternatives. This goes far beyond implied usage, giving the agent clear decision rules.

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

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

No annotations are provided, so the description carries the full burden. It is transparent about the tool's read-only nature (implicit via the GET endpoint note) and thoroughly discloses the output structure. It does not explicitly state 'does not modify data' or discuss potential errors, permissions, or rate limits, but for a metadata retrieval tool, the behavioral expectations are clearly conveyed.

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 long but well-structured with clear headings (Use this tool when, What you'll get, Required parameters, etc.). Every section contributes useful information, though there is some redundancy between 'Use this tool when' and 'Use cases' sections. It is front-loaded with the primary action and remains organized throughout.

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 (returns comprehensive metadata, no output schema), the description compensates admirably. It lists the full spectrum of returned information, includes the API endpoint for context, provides example queries, and covers parameter usage. It leaves little ambiguity about what the tool does and when to invoke it.

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

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

The schema already describes all parameters with examples (100% coverage), so baseline is 3. The description adds value by providing real-world example values (e.g., 'SAP_SC_FI_AM_FINTRANSACTIONS'), explaining the purpose of expand_fields with examples, and mapping parameters to use cases. This goes beyond the schema's dry field names.

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 begins with a clear, specific verb+resource statement: 'Get comprehensive metadata for a specific SAP Datasphere asset.' It then enumerates the detailed metadata fields (dimensions, measures, consumption URLs, relationships, etc.), which clearly distinguishes this tool from siblings like get_asset_by_compound_key or list_space_assets by focusing on a single asset's complete metadata.

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 an explicit 'Use this tool when' section with concrete scenarios (e.g., 'Show me details about the Financial Transactions asset') and a 'Use cases' list. However, it does not explicitly mention when not to use it or suggest alternative tools, stopping short of the full 5-point criteria for exclusions/alternatives.

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

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

There are no annotations, so the description carries the full burden. It discloses the source ($metadata) and return payload (variables, filter annotations, column list) with variable attributes. This is adequate for a read-only metadata retrieval operation, though it stops short of stating side-effect absence or potential errors.

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

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

The description is concise: two sentences that front-load the action, then provide usage guidance and a summary of return values. Every sentence earns its place 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?

The description covers the main use case (pre-query variable discovery), return fields, and the metadata source. It omits details on filter annotation structure or the meaning of 'wave 2026.10', but for an agent deciding whether to invoke the tool, the information is 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?

Schema descriptions already cover both parameters (asset_id and space_id) with 100% coverage, so the description adds only marginal semantic context by referring to 'asset' and 'parameterised'. It does not further explain the parameters' relationship or any constraints beyond the schema.

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

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

The description clearly states the tool retrieves input variables and filter-capability annotations from the OData $metadata of a SAP Datasphere asset. It specifies the exact resource (asset metadata) and distinguishes itself from sibling tools like get_asset_details or get_analytical_metadata by focusing on parameters and filter annotations.

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

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

It provides explicit usage context: 'Use this when the asset is parameterised' and before querying to know bindable variables and filterable fields. However, it does not name alternative sibling tools for non-parameterised assets, so the guidance is clear but not fully comparative.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool shows granted vs. available scopes, includes scope descriptions, and lists the token's current scopes, which goes beyond a simple listing. It implies a read-only operation with no side effects.

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

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

The description is three sentences, each adding value: it lists the output, the included details, and the usage scenario. No redundant information.

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

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

With no parameters, no output schema, and no annotations, the description fully covers what the tool does, what it returns, and when to use it. Nothing is missing.

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

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

The tool has zero parameters, so schema coverage is 100%. The description correctly adds no parameter-specific information since none exist. Baseline for zero-param tools is 4.

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

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

The description clearly states the tool lists OAuth2 scopes for the current user, distinguishing between granted and ungranted scopes. This is a specific verb+resource that differentiates it from sibling tools like get_current_user or get_tenant_info.

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

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

The description explicitly says to use it to understand API access capabilities and troubleshoot permission issues. It provides clear context for when to use the tool, though it does not mention alternatives or exclusion criteria.

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

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

With no annotations, the description carries the full burden. It clearly indicates a non-mutating read operation ('Get') and describes the returned data (user ID, roles, permissions, account status). It does not explicitly state that no side effects occur, but the verb and context make this apparent for a simple profile endpoint.

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

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

The description is two sentences, front-loaded with the main action, and every phrase earns its place. It lists result fields without redundancy and provides a clear usage context.

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

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

For a simple zero-parameter tool with no output schema, the description is complete: it states what the tool does, what information it returns, and gives a practical use case. No additional context is necessary to invoke or interpret the result.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuously). The description adds no parameter details because none exist. A baseline of 4 is appropriate since the schema is complete and no parameter explanation 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 description uses a specific verb 'Get' and identifies the resource as 'authenticated user information', listing key fields (ID, email, roles, etc.). This clearly distinguishes it from sibling tools like get_tenant_info or list_database_users.

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

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

The description explicitly states when to use the tool: 'Use this to understand the current user's identity and access rights.' While no alternative tools are mentioned, the context is clear and there are no direct siblings that compete with this purpose, making the guidance sufficient.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that the tool returns deployment status, runtime metrics, execution history, and performance statistics, and implies a read-only listing operation. It does not mention auth requirements or limitations, but for a list operation this is acceptable.

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

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

The description is two sentences, front-loaded with the core purpose and followed by concrete use cases. Every word earns its place, with no redundancy or filler.

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

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

The tool has no output schema and no annotations, so the description must convey return value nature. It mentions deployment status, metrics, execution history, and performance statistics, which gives a reasonable picture. It could be more explicit about output structure or the fact that both active and inactive objects can be listed, but overall it is adequate for a moderately parameterized tool.

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

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

Schema description coverage is 100%, with all six parameters documented in the input schema. The description adds general context about what metrics and statuses are returned but does not provide parameter-specific details beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'runtime/deployed objects', specifying it operates in SAP Datasphere. It distinguishes the tool from sibling asset-listing tools by focusing on runtime/deployed objects and monitoring use cases.

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

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

The description explicitly says 'Use this for monitoring deployed assets, tracking execution status, analyzing runtime performance, and identifying active vs inactive objects.' This provides clear use contexts, though it stops short of naming alternative tools or explicit exclusions.

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

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

With no annotations provided, the description must carry the burden of disclosing behavior. It clearly indicates a read-only 'get' operation and details what content is retrieved (columns, keys, SQL, dimensions, transformations). While it doesn't mention permissions or side effects, the read-only nature is implied by the verb 'Get' and the listed return content.

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

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

The description is concise and well-structured: two sentences that front-load the core purpose and then provide additional detail on object types and use cases. Every sentence adds value without 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?

Given the tool's complexity and lack of an output schema, the description provides helpful context by listing what is returned for each object type. It also differentiates from sibling tools by covering multiple object types, though it doesn't specify response structure or pagination. This is reasonably complete for a retrieval tool.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description does not add any additional parameter-specific semantics beyond what the schema provides, which aligns with the baseline score of 3.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('complete design-time object definition from SAP Datasphere repository'). It enumerates specific object types (tables, views, analytical models, data flows) and their content, which differentiates it from siblings like get_table_schema or get_asset_details.

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 use cases: 'understanding object implementation details, extracting schema information, or planning migrations.' This gives clear context for when to use the tool, though it does not explicitly mention when to prefer alternatives like get_table_schema or get_analytical_model.

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

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

With no annotations, the description carries the full burden. It states 'Get' (read-only) and enumerates the returned metadata types, which is useful. However, it does not disclose any limitations, authentication requirements, error behavior, or how include_sql_types affects the response, leaving some transparency gaps.

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

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

The description is two sentences with no extraneous words. The core purpose is front-loaded, and the second sentence adds relevant context about the intended workflow. Every word earns its place.

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

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

Given no output schema, the description adequately describes return content (column definitions, data types, SQL type mappings, ETL capabilities). It does not cover error scenarios or pagination, but for a metadata retrieval tool with simple parameters, this is sufficient and complete enough for an agent.

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

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

Schema coverage is 100% with detailed descriptions for all three parameters. The tool description does not add parameter-specific meaning beyond implying that the tool targets a specific entity (asset_id, space_id). Baseline 3 is appropriate since the schema handles parameter documentation.

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

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

The description clearly states the tool's function: 'Get detailed metadata for a specific relational entity' and enumerates the content (column definitions, data types, SQL type mappings, ETL extraction capabilities). This distinguishes it from siblings like get_relational_metadata (broader scope) and get_table_schema (narrower focus on table columns).

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 specifies the tool's niche: 'Optimized for data warehouse loading and transformation workflows,' which implies when to use it. However, it does not explicitly mention alternatives or cases where other metadata tools would be preferable, so it lacks explicit exclusions.

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

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

No annotations are provided, so the description carries the full burden. It transparently discloses the return content ('complete schema information including tables, columns, data types, primary/foreign keys, and relationships') and the SQL type mapping behavior. It does not mention potential limitations or output format, but for a read-only metadata retrieval tool, the level of disclosure is sufficient.

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 sentences, front-loaded with the main action, and each sentence adds value: what it does, what it returns, and a key feature. No fluff or redundant phrasing.

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

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

With no output schema, the description sufficiently explains what the tool returns (complete schema info, relationships, SQL type mapping). It covers the core need for relational access and ETL planning. However, it could be slightly clearer about how this differs from similar metadata tools, and it doesn't mention any pagination or limit behavior, which might matter for large assets.

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

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

The schema description coverage is 100%, so all three parameters are already documented. The description adds no extra meaning beyond what the schema provides; it only mentions SQL type mapping, which is already described in the schema. Baseline 3 is appropriate since the description doesn't need to compensate.

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 function: 'Retrieve CSDL metadata for relational consumption of a specific asset.' It specifies the resource (CSDL metadata for a specific asset) and the purpose (relational consumption), and it lists concrete deliverables (tables, columns, data types, keys, relationships) that distinguish it from siblings like get_analytical_metadata or get_table_schema.

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

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

The description gives context ('for relational data access and ETL planning') which implies when to use it, but it does not explicitly differentiate from closely related siblings like get_relational_entity_metadata or list_relational_entities. There is no explicit 'when not to use' or alternative recommendation, leaving some ambiguity.

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

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

Since no annotations are provided, the description carries the full burden. It details what the tool returns: asset names, descriptions, types, exposure status, consumption URLs, timestamps, counts, pagination. It also notes the underlying API call. It does not mention auth requirements or rate limits, but for a read-only listing tool, the transparency is high.

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 fairly long but well-structured into clear sections (use cases, parameters, examples, filters, asset types). Each section adds relevant information without redundancy. It is appropriately sized for the tool's complexity.

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 4 parameters, no output schema, and no annotations, the description is remarkably complete. It covers all parameter usage, provides practical examples, common OData filter patterns, and lists asset types. An agent can fully understand how to invoke the tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant value with example values ('SAP_CONTENT'), default values for top and skip, common filter examples, and descriptions of asset types. This goes beyond the schema definitions.

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

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

The description clearly states 'List all data assets within a specific SAP Datasphere space' with a specific verb and resource. It distinguishes from siblings like list_catalog_assets and search_catalog by focusing on assets within a single space.

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

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

The description explicitly lists user queries and scenarios that trigger the tool, such as 'What assets are in the SAP_CONTENT space?' and 'Filtering assets by type within a space.' However, it does not provide explicit when-not-to-use guidance or name alternative tools.

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

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

No annotations are provided, so the description carries full burden. It discloses output contents (metadata, tables/views, schemas, row counts, connection info) and error behavior (if space not found, list_spaces() shows available spaces). It does not explicitly state read-only nature, but the wording strongly implies it.

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

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

The description is well-structured with clear sections (purpose, when to use, what you'll get, parameter, examples, errors). It is slightly verbose but every section adds practical context. Slight redundancy with the parameter requirement already in schema, so not perfect.

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 compensates with a detailed list of returned data types. It covers purpose, usage, expected output, parameter specifics, and error handling. Missing only minor details like performance implications, but is sufficient for correct invocation.

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

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

Schema coverage is 100% and already documents space_id with UPPERCASE requirement and examples. The description repeats this without adding new semantic meaning, so it meets the baseline but does not go beyond.

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

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

Description opens with a specific verb and resource: 'Get comprehensive information about a specific SAP Datasphere space.' It clearly lists what is included (metadata, tables/views, schemas, row counts, connection info) and implicitly distinguishes from sibling tools like list_spaces by focusing on a single space.

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?

Includes a dedicated 'Use this tool when' section with concrete triggers (user asks about a specific space, need to see tables/views, checking configuration). It explicitly mentions following up from list_spaces() results and suggests list_spaces as an alternative when space is not found.

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?

Since no annotations are provided, the description must disclose behavioral details. It does so by listing what the response includes (column list, data types, primary key indicators, descriptions, table metadata) and noting the case-sensitivity of the table name. It doesn't mention potential errors or permission requirements, but for a read-only schema lookup, the disclosure is reasonably thorough.

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 longer than average but well-structured with clear headings and bullet points. Each section (use cases, expected output, parameters, examples, best practices, next steps) contributes to usability. There is some minor redundancy with schema details, but the organization makes it easy to scan quickly.

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

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

For a tool with only 2 parameters, no output schema, and no annotations, the description is extremely comprehensive. It covers when to use the tool, what results to expect, parameter constraints, example queries, best practices, and follow-up steps. An agent has all the information needed to select and invoke this tool correctly.

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

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

Schema coverage is 100%, so the input schema already fully documents both parameters with examples and uppercase requirements. The description's 'Required parameters' section and example queries reinforce this but add little new meaning beyond the schema. It provides contextual usage examples, but the baseline 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 'Get detailed schema information for a specific table or view' with a specific verb and resource. It distinguishes itself from sibling tools like search_tables (which finds table names) and execute_query (which runs queries) by specifying that this tool retrieves schema details, and provides example queries that make the purpose 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 tool explicitly lists 'Use this tool when:' scenarios, 'Best practices' (including 'Use search_tables() first if you don't know the exact table name'), and 'Next steps' (suggesting execute_query()). This gives clear when-to-use guidance and names alternative tools, making it easy for an agent to decide between this and related tools.

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

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

With no annotations provided, the description carries the full burden. It discloses sorting order ('Sorted by most recent first'), statuses included, and detailed response fields. It also mentions the API endpoint. However, it does not mention potential limits, pagination, or error behavior, which would be useful for full transparency, but the disclosure is still strong.

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 long but well-structured with clear headings, bullets, and sections. It is front-loaded with the core purpose and then provides examples and use cases. Some redundancy exists between 'What you'll get' and 'Response includes', but overall it is scannable and every section contributes value.

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

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

There is no output schema, so the description compensates by thoroughly listing every response field with descriptions. It also provides a workflow example, API endpoint, and use cases. For a tool with only two simple parameters, this is comprehensively 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?

Schema description coverage is 100% and each parameter already has an informative description including examples and casing requirements. The tool description repeats these examples and adds query examples, but does not introduce new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Get the execution history for a specific task chain or object in SAP Datasphere.' It clearly differentiates from siblings like get_task_status (status) and get_task_log (log details) by focusing on historical runs. The 'Use this tool when' list further reinforces its 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?

Explicit 'Use this tool when' section lists six concrete use cases. The workflow example demonstrates how to chain get_task_history with get_task_log, indicating when to use the alternative. Example queries provide practical context for invocation.

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

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

No annotations are provided, so the description carries the full burden. It discloses the underlying API (GET), explains the four detail_level outputs, lists response fields (logId, status, messages, children), and enumerates possible status values. This is exceptionally transparent.

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

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

The description is well-structured with sections and bullet points, but it is quite verbose for a simple read tool. There is redundancy between 'What you'll get' and 'Optional parameters' both explaining detail_level, and the 'Use cases' section largely repeats the 'Use this tool when' list.

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, but the description compensates thoroughly by detailing response contents, status values, example queries, and use cases. It gives an AI agent everything needed to select and invoke the tool correctly.

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

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

Schema documentation covers all 3 parameters with descriptions, so the baseline is 3. The description adds extra value by explaining where log_id comes from, providing example space_id values, and elaborating on the detail_level enum beyond the schema's bare enumeration.

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

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

The description uses a specific verb 'Get' and identifies a precise resource: 'detailed information about a specific task execution in SAP Datasphere'. It clearly distinguishes this from sibling tools like get_task_status and get_task_history by focusing on a single log and referencing run_task_chain.

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

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

Provides explicit 'Use this tool when' scenarios (checking status, investigating failures, viewing logs, monitoring progress). It also indicates log_id provenance from run_task_chain or get_task_history. However, it lacks explicit when-not-to-use guidance or named alternatives like get_task_status.

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

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

With no annotations, the description carries the transparency burden. It discloses return contents (task IDs, status, timestamps, duration, records), filtering options, and task types. It doesn't explicitly state it's read-only, but the verb 'get' and context make that clear.

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?

Well-structured with clear sections and bullets, but a bit verbose. Every section contributes useful information, though the 'Task types' list is somewhat redundant with the overall purpose.

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

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

Given no output schema and only two optional parameters, the description is remarkably complete. It covers when to use, what to expect, filtering behavior, example queries, and return fields, leaving little ambiguity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by explaining the no-parameter behavior, how each filter works, and providing concrete example values for each parameter.

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

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

The description clearly states the tool retrieves status and execution details for data integration/ETL tasks. It distinguishes itself from siblings like get_task_history and get_task_log by focusing on current status and run details, supported by explicit examples.

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

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

Provides clear 'Use this tool when' scenarios and example queries. It gives strong contextual guidance but does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden. It describes what is retrieved but does not explicitly state safety traits like read-only behavior, permission requirements, rate limits, or any side effects. The verb 'Retrieve' implies a read operation, but the description adds no deeper behavioral disclosure.

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

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

The description is a single well-structured sentence that front-loads the primary purpose, then enumerates key fields and ends with a usage note. Every phrase earns its place, with no redundant or filler content.

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

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

For a parameterless read tool with no output schema, the description is quite complete: it lists the returned data types (tenant ID, region, version, etc.) and the use case. It does not mention error cases, authentication needs, or response format, but the level of detail is adequate for a simple retrieval tool.

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

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

The input schema is empty (0 parameters), so the baseline is 4. The description correctly implies that no parameters are needed, and there is nothing more to explain about parameter semantics.

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

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

The description clearly states it retrieves SAP Datasphere tenant configuration and system information, listing specific fields. It uses a specific verb ('Retrieve') and resource ('tenant configuration'), but does not explicitly distinguish from sibling tools like get_space_info or get_current_user, though the tenant-level scope is implicit.

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

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

It explicitly says 'Use this for system administration and capacity planning,' providing clear context for when to use it. However, it does not mention when not to use it or name alternative tools, so it lacks exclusions/alternatives.

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

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

With no annotations provided, the description carries the full transparency burden. It correctly frames the operation as a read-only listing and explicitly states what is returned, which is the most important behavioral trait. It doesn't mention auth or side effects, but for a list operation this is reasonably sufficient.

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

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

Three sentences, front-loaded with the core verb and object, and every sentence adds useful information about purpose, scope, or return value. There is no wasted verbiage.

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 paginated list tool with no output schema, the description adequately covers what the tool does, its scope, and what it returns. It doesn't need to repeat schema details, and the overall context is sufficient for an agent to select it appropriately.

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

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

The input schema already covers all four parameters with descriptions, examples, and defaults, so the description adds no additional parameter semantics. This matches the baseline score of 3 when schema coverage is high.

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 ('List') and a specific resource ('analytical datasets within a specific asset'), clearly distinguishing this discovery tool from query-oriented or metadata-only siblings. It also names the expected return content (entity sets, names, types, URLs), making the purpose unmistakable.

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

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

The description clearly frames when to use the tool: to discover analytical datasets/models that can later be queried for business intelligence. It does not explicitly name alternative tools or exclusion criteria, but the 'can be queried' phrasing implies this is the discovery step, so the usage context is clear.

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

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

With no annotations provided, the description carries the full burden of disclosure. It transparently describes the return fields (IDs, names, types, spaces, URLs, timestamps), pagination parameters with defaults and limits, and even includes the underlying Catalog API endpoint. It implies read-only behavior through 'browse' and 'consumption URLs,' though it does not explicitly state that it is a read-only operation or discuss rate limits or error behavior.

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

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

The description is well-structured with clear sections: purpose, when-to-use, expected output, parameters, examples, filters, asset types, and a note. The opening sentence states the core function immediately. While the description is long, every section provides actionable details and no superfluous content. It earns a 4 rather than 5 due to its length; a more compact version could retain the same value.

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

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

Given the tool's complexity (5 optional parameters, no output schema, no annotations), the description is exceptionally complete. It explains what results look like, provides usage guidelines, gives numerous examples, details common filters, and even names the underlying API. It fully equips an agent to know when and how to invoke the tool correctly.

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

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

The input schema already documents all 5 parameters with 100% coverage, so the baseline is 3. The description adds value by providing concrete examples for filter_expression (e.g., spaceId eq 'SAP_CONTENT'), showing typical select_fields usage, and giving common filter combinations. It also explains asset types that appear in results, which enriches the parameter meaning beyond the schema.

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

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

The description opens with a clear, specific statement: 'Browse all data assets across all SAP Datasphere spaces.' This distinguishes it from siblings like get_space_assets (specific space) or find_assets_by_column (column-specific search). The 'Use this tool when' section further reinforces the tool's role as a system-wide catalog browser.

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 an explicit 'Use this tool when' list with concrete scenarios like building a complete data catalog or discovering assets across all spaces. However, it does not name alternative tools for exclusion, such as 'use search_catalog for targeted text search' or 'use get_space_assets for a single space.' This is clear context but lacks explicit when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden. It discloses return fields (IDs, names, types, status, host, timestamp) and lists supported connection types. It does not explicitly state the operation is read-only, nor does it mention permissions or error behavior, but the 'List' verb and status focus imply a non-mutating operation. This is a solid but not exhaustive disclosure.

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

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

The description is front-loaded with a clear one-sentence summary, then organized into scannable sections with bullets. Every section—supported types, example queries, use cases—provides distinct value. There is no fluff or repetition; the length is justified by the rich context.

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

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

For a simple tool with one optional parameter, no annotations, and no output schema, the description is remarkably complete. It explains what the user will get in terms of return content, lists valid connection types, and gives concrete usage examples. Nothing critical is missing for the agent to select and invoke the tool correctly.

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

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

The schema already describes the single optional parameter with examples, giving 100% coverage. The description adds value by enumerating possible connection types (SAP_ERP, SALESFORCE, etc.), which is not in the schema. This goes beyond the baseline, though the core semantics are already clear from the schema.

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

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

The description opens with a specific verb 'List' and a well-defined resource: 'all external data source connections and their current status.' This clearly distinguishes it from sibling tools like test_connection (which tests) and get_task_history (which shows task history). The purpose is unmistakable.

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

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

The description provides an explicit 'Use this tool when' section with concrete examples like 'What data sources are connected?' and 'Checking connection health.' It also lists example queries and use cases. However, it does not include explicit when-not-to-use guidance or name alternative tools, so it stops short of a perfect score.

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

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

No annotations are provided, so the description carries full burden. It explains the output structure ('What you'll get') and access types, giving good insight into behavior. However, it does not explicitly state that the operation is read-only or mention side effects of the optional output_file parameter, so it falls short of perfect transparency.

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

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

The description is well-structured with clear headings, bullet points, and examples. It front-loads the primary purpose and provides necessary details in an organized manner without unnecessary verbosity. Every section (usage, output, required param, examples, access types) contributes value.

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

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

There is no output schema, so the description compensates by detailing the expected return values (user IDs, status, permissions, etc.). It also includes example queries and a CLI reference, making it comprehensive for a list operation. The optional output_file is covered by the input schema, so the description remains 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?

Schema coverage is 100%, and the description repeats the space_id parameter with uppercase examples, adding minimal value beyond the schema. The output_file parameter is not mentioned in the description at all, so the description does not significantly enhance parameter understanding beyond what the schema already 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 clearly states the tool's function: 'List all database users in a specific SAP Datasphere space.' It uses a specific verb (list) with a resource (database users) and scope (space), and distinguishes itself from sibling tools like create/update/delete_database_user.

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

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

The 'Use this tool when' section explicitly lists scenarios such as auditing user access and checking who has database access to a space. It also advises using it before creating a new user to avoid duplicates, providing clear context for when to use this tool over alternatives.

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

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

With no annotations, the description carries the full burden, but it only says 'Returns OData entity sets' without stating that the operation is read-only, requires specific permissions, or has side effects. It does not disclose pagination behavior or other limitations beyond the schema's top parameter, leaving significant ambiguity about execution behavior.

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

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

The description is two sentences, front-loaded with the main verb and resource, and contains no redundant wording. It efficiently communicates purpose and return type.

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 listing tool, the description covers the core action and return type, but without annotations or an output schema it leaves gaps: what exactly an 'OData entity set' contains is unspecified, and pagination is only hinted at via the top parameter. It is adequate but not rich.

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 space_id, asset_id, and top are already fully documented with examples and defaults. The description adds no additional parameter-specific meaning, only a general reference to 'a specific SAP Datasphere asset' that loosely maps to the required 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 clearly states the action: 'List all available relational entities (tables/views) within a specific SAP Datasphere asset.' It also clarifies the return type ('Returns OData entity sets') and distinguishes the tool from query or metadata tools by focusing on enumeration.

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 'within a specific SAP Datasphere asset for row-level data access and ETL operations' gives context on when the tool is useful, but it does not explicitly contrast with sibling tools like query_relational_entity or get_relational_entity_metadata. Usage guidance remains implicit rather than direct.

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 are absent, so the description carries the full burden. It discloses what the tool returns (space IDs, names, status, counts, owner with include_details=True) and implies a read-only operation via 'list.' However, it does not explicitly state permissions, pagination, or potential errors, which would be even more transparent. The default behavior and detail flag are explained, earning a 4.

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

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

The description is well-structured with clear sections and is front-loaded with the main purpose. Some content, like example queries, is slightly redundant but still useful for intent recognition. It is not overly verbose, so 4 is appropriate.

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 read-only list tool with one optional parameter and no output schema, the description thoroughly covers use cases, expected outputs, parameter semantics, and next steps. It is fully complete for an agent to understand when and how to invoke it.

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

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

Schema coverage is 100%, so the schema already documents include_details well. The description adds minor context by mentioning 'quick space listing' vs. detailed information, but largely duplicates the schema's parameter description. Thus it meets the baseline without significant added meaning.

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

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

The description clearly states it lists all SAP Datasphere spaces with their status and metadata. It distinguishes itself from siblings by mentioning it's for discovering spaces, while get_space_info is for exploring a specific space and search_tables is for finding tables. This provides a specific verb-resource pair with scope.

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 'Use this tool when' bullets, example queries, and next steps that point to alternatives like get_space_info and search_tables. This constitutes clear usage context and alternative guidance, satisfying the highest bar.

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

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

With no annotations present, the description carries full responsibility for behavioral disclosure. It provides several non-obvious behavioral details: filtering dimensions is cheaper than filtering measures, federated sources support only eq/and/or/(), values must be single-quoted and are case-sensitive, and a value containing a single quote cannot be filtered on. This goes well beyond the schema and informs the agent of important limitations and performance characteristics.

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