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

With no annotations, the description carries the full burden and does disclose meaningful side effects: it 'submits changes to Raylight' and 'permanently commits changes to the repository' when save=True. It stops short of stating irreversibility, permission requirements, or what happens on failure, which for a mutating, repository-writing tool would be valuable.

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 opening sentence front-loads the operation and the parameter block is well organized and scannable. It is somewhat long, but nearly every line carries operational information rather than filler.

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

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

For a 6-parameter mutating tool with an output schema (so return values need no explanation), the description covers the workflow, all parameters, and key side effects. The main remaining gap is guidance on alternatives and failure/rollback behavior, which would round it out.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every one of the six parameters is documented with meaning, defaults ('SameID,SamePath,SameName', save=True), format conventions ('DP0'), and a concrete example for custom_mappings. This adds substantial meaning beyond the bare schema 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?

States a specific verb+resource ('Executes Change Data Source on a Web Intelligence Data Provider') and clarifies scope with concrete examples ('migrating UNV to UNX or repointing universes'). This clearly separates it from read-side siblings like get_dp_mapping_proposal and get_dp_specification.

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

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

The description implies the usage context (universe migration/repointing) and sketches a workflow, but never states when to choose this over alternatives such as get_dp_mapping_proposal (preview-only) or refresh_dp. An agent must infer that this is the committing tool rather than being told explicitly.

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

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

With no annotations, the description carries the full behavioral burden. It implies read-only via SELECT examples but never states whether DML is allowed, what permissions are required, whether queries are injectable/sandboxed, or how pagination behaves despite page/pagesize existing. It only partially discloses the core behavior (arbitrary query capability).

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

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

Front-loaded with the core capability, then two compact, concrete examples that earn their place by illustrating syntax the schema cannot express. No filler or restated boilerplate.

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 existence of an output schema relieves the description of explaining return values, and the examples make the query syntax usable. However, pagination semantics and behavioral constraints (read-only, permissions, limits) are unaddressed, leaving an agent with a capable-looking but under-specified tool.

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

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

Schema description coverage is 0% across all 3 parameters. The examples give real value for the 'query' parameter (table names and SELECT syntax), but 'page' and 'pagesize' are entirely undocumented in both schema and description, leaving two-thirds of the inputs unexplained.

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

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

States a specific verb (Executes an arbitrary SQL-like query) and the exact resource (the CMS repository tables, named explicitly). This clearly differentiates it from the many narrow getters in the sibling list, which all read one specific resource type.

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 examples show what a query looks like, but nothing states when to use this generic query tool vs. the dedicated siblings (get_users, get_documents, get_doc_details). There is no guidance on preferring specific tools when they exist, no read-only/write restriction statement, and no mention of performance or cost tradeoffs.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only conveys that the folder is nested under a parent; it says nothing about permission requirements, behavior on duplicate names, error conditions, or whether the operation is reversible.

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

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

A single front-loaded sentence with zero filler; the verb and resource come first. It is appropriately sized, though its brevity comes at the cost of the missing detail noted in other dimensions.

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

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

An output schema exists so return values needn't be explained, but with no annotations and 0% parameter coverage the description leaves too much unsaid: no auth/permission notes, no failure modes, and no clarification of the two required parameters for an agent to invoke it confidently.

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

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

Schema description coverage is 0% across 3 parameters, so the description must compensate. It only implies parent_folder_id via 'under a parent folder' and never addresses the 'name' or optional 'description' parameters, leaving all three effectively undocumented.

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

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

States a specific verb ('Creates') and resource ('folder') plus the repository scope ('InfoStore') and parent-child placement. It is clearly distinguishable from siblings like get_folders, get_folder_details, and delete_folder, though it doesn't name any of them explicitly.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites (e.g., the parent folder must exist, authentication/authorization needed), and no mention of related tools such as get_folders to discover a valid parent_folder_id.

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 destructive-operation burden. "Permanently" usefully signals irreversibility, but nothing is said about required permissions, cascade behavior on folder contents, or preconditions such as an empty folder.

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

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

A single front-loaded sentence with zero waste. It is efficient, though arguably too terse given the destructive nature and the undocumented parameter.

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 an irreversible delete with no annotations and an undocumented required parameter, this is under-specified. The output schema spares it from explaining return values, but permission, cascade, and precondition context are missing.

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

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

One parameter with 0% schema description coverage: folder_id is a bare string with no explanation in either schema or description. The description only implies it identifies the target folder, adding no format, scope, or identifier-type detail.

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

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

States a specific verb and resource ("Permanently deletes a folder") and locates it in the InfoStore repository, which separates it from siblings like delete_webi_doc, delete_instance, or create_folder. It does not explicitly name the boundary against get_folder_details or create_folder, but the resource is unambiguous.

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

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

There is no when-to-use guidance, no prerequisites, and no stated alternatives. An agent gets no signal about whether the folder must be empty, what happens to contained documents, or when to prefer a non-destructive sibling.

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

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

With no annotations, the description carries the full behavioral burden for a clearly destructive operation. It reveals only that the target is a 'historical' execution instance; it says nothing about permanence/irreversibility, required privileges, or effect on scheduled runs. That is a thin disclosure for a delete.

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

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

A single front-loaded sentence with no filler or redundancy; the verb-resource statement comes first. It is efficient, though arguably too terse given the destructive nature of the tool.

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

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

An output schema exists, so return values need not be explained. However, for a destructive tool with no annotations and 0% parameter coverage, the description omits the behavioral and usage context an agent needs to invoke it safely and correctly.

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

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

Schema description coverage is 0% for the single required parameter instance_id, and the description never explains what an instance identifier is or where to obtain it. The word 'instance' only loosely hints at the parameter, so the description does not compensate for the documentation gap.

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

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

States a specific verb ('Deletes') and a specific resource ('historical report execution instance from the CMS repository'), which is naturally distinct from sibling resources like documents, folders, sessions, and datapoints. It does not explicitly name or contrast with the nearest siblings (get_instance_details, get_doc_instances), so it stops short of full differentiation.

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

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

The description gives no when-to-use context, no prerequisites (e.g. permissions or whether the instance must be finished), and no mention of alternatives such as get_instance_details for inspection first. Nothing helps an agent decide when this tool is the right call.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the most critical trait, that deletion is permanent/irreversible ('Permanently deletes'), which is genuinely useful. It omits other important context such as authentication requirements and what happens to existing instances, schedules, or dependencies of the document.

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

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

One efficient, front-loaded sentence with zero filler. It is arguably too terse for a destructive operation, but there is no wasted text.

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

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

An output schema exists, so return values need not be explained, and the permanence of the operation is stated. However, for a destructive tool with no annotations and an undocumented identifier, the description is thin on prerequisites and side effects, leaving meaningful gaps 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 description coverage is 0% and the description adds no meaning about webi_doc_id (format, where to obtain it, whether it is a CUID or numeric ID). With low coverage the description should compensate but does not, though the single-parameter surface limits the damage.

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?

Clear specific verb (deletes) plus resource (Web Intelligence document) and scope (from the repository). An agent knows exactly what is being removed. It does not, however, explicitly differentiate itself from siblings like delete_folder, delete_instance, or purge_dp, though the resource noun is fairly distinct.

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

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

No when-to-use guidance, no prerequisites (e.g. required login/session state), and no alternatives named. The single sentence states the effect but leaves the agent to infer when this tool is the right choice versus delete_instance or purge_dp.

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

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

With no annotations, the description carries the full behavioral burden. 'Monitors' implies a read-only observation of currently open sessions, and the output schema covers return values, but the description does not state authentication requirements, rate limits, or explicitly that it is non-mutating.

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

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

A single, front-loaded sentence with no wasted words. It states the observed resource and scope efficiently.

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

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

For a simple, parameterless read tool with an output schema, the description is mostly complete. It could say more about permissions or confirm read-only behavior, but the core purpose and scope are covered.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the empty schema leaves nothing undocumented.

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

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

The description gives a clear verb ('Monitors') and a specific resource ('active connections and user sessions currently open on the Central Management Server'). It does not distinguish this tool from the sibling terminate_session, so it falls short of a 5.

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

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

The description offers no explicit when-to-use guidance or alternatives. It implies monitoring active sessions, but provides no context for choosing this tool over related tools such as terminate_session or get_users.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a safe, non-destructive read ('Lists all'), which is useful, but it discloses nothing about required permissions, filtering/pagination, or 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?

A single front-loaded sentence with zero filler; the resource and scope are stated immediately.

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

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

For a parameterless listing tool with an output schema that already documents return values and no annotations to reconcile, the description is sufficient. Only minor gaps remain around any access requirements.

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

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

The tool takes zero parameters, so the baseline of 4 applies. Schema coverage is 100% and there are no parameters to misinterpret.

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

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

States a specific verb ('Lists'), a specific resource ('Corporate Categories'), and the scope ('all ... defined in the BI platform repository'). No sibling tool competes for categories, so there is no risk of confusion with get_universes, get_documents, or get_reports.

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

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

The description offers no when-to-use guidance, prerequisites, or alternatives. There is only an implicit 'call this to enumerate categories', with nothing about authentication or ordering relative to other repository queries.

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 load. It usefully discloses the content scope (user comments plus cell-level annotations) that the parameter schema does not convey, but says nothing about read-only nature, permissions, pagination, or how much history is returned.

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

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

A single front-loaded sentence with zero filler; the object of retrieval is stated immediately. It is terse rather than verbose, though the terseness edges into under-specification.

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

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

An output schema exists, so return values need not be explained. However, for a retrieval tool with an undocumented required parameter and no annotations, the description omits permissions, scope of results, and any usage context, leaving it minimally complete.

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

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

One parameter with 0% schema description coverage, so the description must compensate. 'In a Webi document' implies webi_doc_id identifies the target document but gives no format, expected ID source, or error behavior, leaving the parameter only partially explained.

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

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

States a specific verb ('Retrieves') and a specific resource ('collaborative user comments and cell annotations') scoped to 'a Webi document'. It is unambiguous what the tool does, though it does not explicitly name or contrast itself with any sibling.

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

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

No guidance on when to call this versus alternatives, no prerequisites, and no statement of what the caller needs beforehand (e.g., the document must be saved/accessible). Usage is only inferable from the phrase 'in a Webi document'.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieves' implies a read-only operation, but nothing is said about permissions, whether an invalid or inaccessible webi_doc_id errors versus returns empty, or any access constraints. The enumerated return fields are the only added 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?

A single front-loaded sentence with zero filler; the resource and its returned fields are stated immediately.

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

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

An output schema exists, so return values need not be explained (the description repeats them anyway), and for a one-parameter read tool this is largely sufficient. The gaps are the ambiguous webi_doc_id format and the absence of any routing against the several doc-related siblings.

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

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

The single parameter webi_doc_id has 0% schema description coverage and the description adds nothing about its expected format (ID vs CUID). In fact the description lists CUID as a returned field, which could confuse the agent about what the input actually is.

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

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

States a specific verb ('Retrieves') and resource ('metadata of a Webi report') and even enumerates the returned fields, so the operation is unmistakable. However, it does not distinguish itself from close siblings like get_doc_properties, get_documents, or get_webi_docs, leaving the agent to guess which doc-metadata tool to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_doc_properties or get_documents. The agent gets no signal about which sibling to choose for report metadata.

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

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

With no annotations, the description carries the full burden. It does useful work by declaring this is a read operation and enumerating the status values (Success, Failed, Running) and timestamps, but it says nothing about result limits, the existence of the max_instances cap (default 50), ordering, or auth requirements.

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

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

A single front-loaded sentence with no filler; the resource is stated before the returned fields. Efficient, though it trades away any routing or parameter information for brevity.

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

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

An output schema exists, so return-value explanation is not strictly required. However, for a two-parameter tool with 0% schema coverage and no annotations, the description leaves too much unsaid about the limit parameter and when to choose this over get_instance_details.

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

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

Schema description coverage is 0% and the description never mentions webi_doc_id or max_instances. The one parameter that constrains behavior (max_instances, default 50) is left entirely unexplained, so the description fails to compensate for the documentation gap.

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

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

States a specific verb (Retrieves) and resource (historical run instances of a Webi report) and even names the payload fields (execution status, timestamps). It does not distinguish itself from the nearby sibling get_instance_details, which appears to overlap, so an agent cannot fully disambiguate from the text alone.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no named alternative despite a crowded sibling set (get_instance_details, delete_instance, get_doc_schedules). Usage must be inferred purely from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It makes clear this is a read operation and lists the returned fields (ID, question/name, technical name, data type, mandatory flag), which is useful. It says nothing about authentication requirements, error behavior when a document has no prompts, or pagination, so the disclosure is partial.

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

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

Two tightly written sentences with the primary purpose front-loaded and the return values following. No filler or redundancy.

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

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

An output schema exists, so the description is not obligated to explain return values (though it helpfully does). For a simple one-parameter read tool this is largely sufficient; the only meaningful gap is the absence of any hint about sourcing the webi_doc_id or the get_parameter_lov alternative.

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

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

Schema description coverage is 0% for the single required parameter webi_doc_id, and the description never mentions it or explains how to obtain a valid document ID. The parameter name is somewhat self-descriptive, but the description does not compensate for the schema gap.

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

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

States a specific verb (Retrieves) and resource (prompt parameters required by a Web Intelligence report), and even enumerates the returned fields, so the agent knows exactly what it produces. It does not, however, differentiate itself from the sibling get_parameter_lov, which an agent would need in order to disambiguate the two parameter-related tools.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of the closest alternative (get_parameter_lov). Usage can only be inferred from the resource described, leaving the agent to guess between the parameter-related siblings.

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. 'Retrieves' signals a read-only operation and the property list hints at the payload scope, but there is no disclosure of access/permission requirements, error behavior, or what happens with an invalid or inaccessible webi_doc_id.

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

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

A single compact sentence that front-loads the verb and resource, with the property examples in a parenthetical. No filler or redundancy.

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

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

An output schema exists, so return-value explanation is not required, and the description gives a reasonable sense of what comes back. However, for a tool whose only input is undocumented, the definition is thin relative to the schema/annotation richness available.

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

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

Schema coverage is 0% and the single parameter (webi_doc_id) is undocumented in both schema and description. The description does not state what identifier format is expected or where the agent obtains it, so it fails to compensate for the coverage gap.

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

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

States a specific verb ('Retrieves') and resource ('document configuration properties') and enumerates the three concrete properties returned (refreshOnOpen, usePersonalData, formatting locale). It is clearly distinguishable from get_doc_details, though it never names that sibling explicitly.

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

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

No guidance on when to use this instead of the many neighboring read tools such as get_doc_details, get_doc_parameters, or get_webi_docs. The agent is left to infer the selection criteria from the property list alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Lists' does signal a read-only, non-mutating operation, but nothing is said about permissions, whether the document must already have schedules defined, or error behavior for an invalid id. Adequate signal, but thin for an unannotated tool.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficiently sized, though the brevity leaves no room to convey the context this unannotated tool needs.

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

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

An output schema exists, so return values need not be described, and the tool is a simple single-parameter read. Still, with no annotations and no parameter documentation, the description leaves auth requirements and the relationship to sibling listing tools unaddressed.

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

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

Schema description coverage is 0% for the single required parameter webi_doc_id. The phrase 'for a Web Intelligence document' loosely ties the parameter to a document identifier, adding marginal meaning, but it does not clarify expected format, source, or lookup requirements.

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

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

States a specific verb (Lists) and resource (scheduled execution rules for a Web Intelligence document), which is concretely different from siblings like get_doc_instances or get_reports. It does not explicitly name or contrast against those siblings, so it falls short of a 5.

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

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

The description gives no when-to-use guidance, no prerequisites, and no indication of how it relates to alternatives such as get_doc_instances (instances vs. schedule definitions). Usage is only weakly implied by the verb 'Lists'.

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

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

With no annotations, the description carries the full burden. It discloses that results are paginated and enumerates returned fields, but says nothing about ordering, permissions/auth requirements, behavior when page exceeds the result set, or rate limits.

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

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

Two short sentences, front-loaded with the action and scope. The second sentence listing return fields is largely redundant with the existing output schema, which is minor waste rather than bloat.

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

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

An output schema exists, so the return-field sentence is unnecessary, and the real gaps remain: no differentiation from get_webi_docs, no auth/prerequisite context, and no pagination semantics. Adequate but with clear omissions.

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

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

Schema description coverage is 0% — the two parameters (page, pagesize) have defaults but no descriptions. The word 'paginated' is the only hint that page/pagesize control slicing; the 1-based indexing and default page size of 50 are never explained in prose, so the description does not compensate for the coverage gap.

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

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

Specific verb+resource: 'Retrieves a paginated list of Web Intelligence documents from the repository.' An agent knows what it does, but the definition does not distinguish it from the sibling get_webi_docs, which appears to target the same resource, so sibling differentiation is missing.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g., authenticated session required despite login/logout siblings), and no routing to alternatives such as get_webi_docs or get_doc_details.

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 implies a safe read ('Lists') scoped to one document and shows the identifier format, but says nothing about permissions, ordering, or behavior on documents with no Data Providers.

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

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

A single tight sentence with the resource front-loaded and the example identifiers placed where they aid recognition. No filler, though it is arguably too terse given the gaps elsewhere.

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

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

An output schema exists, so return values need not be explained. For a simple single-parameter list tool that is nearly enough, but the absence of any routing guidance among six DP-related siblings leaves a real gap.

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

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

One parameter with 0% schema description coverage. The phrase 'within a Webi document' indirectly signals that webi_doc_id identifies the document to enumerate, but the description never states the parameter name, its expected format, or what happens with an invalid ID.

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

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

States a specific verb and resource ('Lists all Data Provider identifiers') plus a clear scope ('within a Webi document') and example identifier formats. The plural 'identifiers' implicitly distinguishes it from sibling get_dp_details, but no sibling is named or contrasted explicitly.

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

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

The description contains no when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (get_dp_details, get_dp_sql, get_dp_specification) despite a dense sibling set. An agent must infer that this is the enumeration step before drilling into a specific DP.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieves' implies a non-mutating read, which is the right signal, but nothing is said about permissions, whether the Data Provider must exist, or error behavior when dp_id is stale. It adds only marginal context beyond the implied read.

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

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

A single front-loaded sentence with zero waste; the verb and resource lead and the returned fields follow. Nothing could be cut without losing 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?

An output schema exists, so the description is not obligated to explain return values. For a simple read tool with two required identifiers, however, the missing parameter semantics leave a notable hole for correct invocation.

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

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

Schema description coverage is 0% and both parameters (dp_id, webi_doc_id) are required, yet the description never names or explains either one. It gestures at 'a specific Data Provider' but does not clarify that lookup requires both a document ID and a Data Provider ID, nor what formats they take.

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

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

The description gives a specific verb ('Retrieves') and resource ('metadata of a specific Data Provider') and even enumerates the fields returned (name, ID, type, update status). It is clear what the tool does, but it does not distinguish itself from close siblings such as get_dp, get_dp_sql, or get_dp_specification, so an agent cannot tell from the text alone which Data Provider getter to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of any alternative tool. In a sibling set containing get_dp, get_dp_sql, and get_dp_specification, the absence of routing guidance is a real gap.

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

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

With no annotations, the description carries the burden and does well: it discloses that the operation is a simulation (non-destructive), enumerates the outcome states ('Ok', 'Ambiguous', 'NotFound'), and warns that CloseName fuzzy matching should be used with caution. It does not describe the proposal's structure or side effects, but the output schema covers return values.

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

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

The purpose and outcome states are front-loaded, and the strategy list is presented as a clean bulleted sequence with a recommended default at the end. A few phrases are verbose but nearly every sentence earns its place.

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

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

The output schema relieves the description of explaining return values, and behavior is reasonably well covered. However, given the 5-parameter schema at 0% coverage and no annotations, the description leaves too many parameters and the invocation context undefined to be fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It richly documents the 'strategies' parameter with valid values and a recommended default, but leaves webi_doc_id, dp_id, target_datasource_id, and resolve_names entirely unexplained, so compensation is only partial.

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

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

The description states a specific verb and resource: generates/evaluates a Change Data Source mapping proposal and simulates repointing a Web Intelligence query. This clearly distinguishes it from read-only siblings like get_dp_details. It stops short of explicitly contrasting itself with change_dp_datasource, which is the closest sibling.

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

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

Usage is implied through the context of a mapping proposal before a data-source change, and the description gives a recommended default strategy set. It never states when to use this tool versus alternatives such as change_dp_datasource, nor any preconditions or exclusions.

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

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

No annotations are provided, so the description carries full behavioral burden. 'Retrieves' implies a read-only operation, but there is no mention of permissions, side effects, required document state, or any other behavioral trait. This is minimal 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?

A single, front-loaded sentence that efficiently states the action, resource, and returned components. No wasted words.

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

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

An output schema exists so return values need not be described, but the description still leaves parameter meanings and usage context entirely unaddressed. Given no annotations and 0% schema coverage, an agent lacks critical information to call 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 coverage is 0% and the description does not explain either required parameter (dp_id, webi_doc_id). 'Of a Data Provider' hints only vaguely at dp_id and says nothing about webi_doc_id or their relationship. It fails to compensate for the undocumented schema.

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

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

States a specific verb ('Retrieves') and resource ('query specification tree'), and elaborates on contents (result objects, query filters, sort rules). It does not explicitly differentiate itself from sibling tools like get_dp_details or get_dp_sql, so it falls short of a 5.

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

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

No guidance on when to use this tool versus alternatives such as get_dp, get_dp_details, or get_dp_sql. The description only states what it does, leaving context entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Extracts' implies a read, but the description says nothing about authentication requirements, whether the SQL is cached or requires the DP to have been refreshed, or how errors surface when no SQL has been generated.

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

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

A single, front-loaded sentence with no filler; it states the essential operation immediately and stops. Nothing is wasted.

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

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

An output schema exists, so return values need not be explained. However, for a tool with two undocumented required parameters and zero annotation coverage, the description leaves genuine gaps around parameter meaning and usage context.

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

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

Schema description coverage is 0%, and the description mentions neither webi_doc_id nor dp_id. The agent gets no indication of what these identifiers are, their format, or the relationship between the document and the data provider they scope.

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

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

The description names a specific verb (extracts) and a specific artifact (the generated SQL query statement of a Data Provider), which is far more precise than a generic 'get DP info'. It does not, however, explicitly distinguish itself from close siblings such as get_dp_specification or get_dp_details, leaving the agent to infer the boundary.

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

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

There is no statement of when this tool should be used versus alternatives like get_dp_specification or get_dp_details, and no prerequisites (e.g., whether the DP must be refreshed first for SQL to exist). The agent is given no routing guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Retrieves' implies a safe read, and it names the fields returned, but it says nothing about error behavior for missing folders, permission requirements, or rate limits.

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

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

One short sentence, front-loaded with the verb and resource, and the parenthetical field list is compact and informative. No wasted text, though there is little structure beyond the single clause.

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

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

An output schema exists, so return values need not be explained, and the description is adequate for a simple single-resource getter. It still leaves the input identifier semantics and failure modes unspecified, which is a notable gap for a 1-required-param tool with no annotations.

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

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

Schema description coverage is 0% and the single required parameter folder_id has no description anywhere. The description mentions 'CUID' only as a returned field, not as the expected input identifier format, so it does not compensate for the schema gap.

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

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

States a specific verb and resource ('Retrieves metadata of a repository folder') and enumerates the returned fields. It does not explicitly distinguish itself from the sibling get_folders (list) tool, so an agent must infer that this one fetches a single folder by ID.

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

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

There is no statement of when to use this tool versus get_folders, create_folder, delete_folder, or related get_*_details siblings. Usage is only implied by the singular 'folder' noun and the required folder_id.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but never confirms read-only safety, permissions required, recursion depth limits, pagination, or whether the root folder itself is included.

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

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

A single sentence that front-loads the operation and scope with zero wasted words. Nothing could be trimmed without losing meaning.

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

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

An output schema exists, so return-value shape is handled elsewhere. However, with no annotations, no parameter documentation, and no usage context, the definition is only minimally complete for even a simple read 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?

Only one parameter (folder_id) with 0% schema description coverage. The phrase 'starting from a root folder ID' clarifies that the input is the recursion root rather than an arbitrary folder, which adds meaning beyond the bare schema, but format and validity rules remain unspecified.

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

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

States a specific verb (Gets), resource (subfolder IDs), and scope (recursively from a root folder ID). An agent can distinguish this from get_folder_details or create_folder, though the description never names a sibling explicitly to sharpen the contrast.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as get_folder_details for a single folder. The agent must infer the use case from the description alone.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Lists' implies a read-only operation, which is useful, but the description does not disclose pagination behavior, authentication requirements, or whether membership is direct or transitive.

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

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

The description is a single, front-loaded sentence with zero wasted words. It states the tool's behavior immediately and does not bury the core action.

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

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

An output schema exists, so return values need not be described. However, for a tool with no annotations and an undocumented required parameter, the description is only minimally complete; it does not explain group_id format or usage context.

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

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

Schema description coverage is 0%, so the description must compensate for the one required parameter. It only implies that group_id refers to a 'User Group' but gives no format details, such as whether it expects an ID or a group name, or where to obtain it.

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

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

The description uses a specific verb, 'Lists,' and a precise resource, 'users that are members of a specific User Group.' It clearly distinguishes this tool from siblings such as get_users and get_user_groups, which operate on all users or on groups themselves.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing a valid group identifier, or when another sibling like get_users would be more appropriate.

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

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

With no annotations, the description carries the full burden. It usefully discloses what the response contains (failure error messages, file sizes), which is more than a generic 'get details' would, but it says nothing about read-only safety, permissions, or whether any state changes.

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

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

Two tight sentences with the purpose front-loaded and the return-content detail appended. No redundant or filler wording; appropriately sized for a simple getter.

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

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

An output schema exists, so return values need not be spelled out; the description nonetheless summarizes them. The remaining gap is invocation guidance for the single undocumented parameter and any note on how to obtain a valid instance_id, which leaves the definition merely adequate.

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

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

Schema description coverage is 0% for the single parameter, so the description must compensate. It clarifies that instance_id identifies a 'specific instance run', but gives no format, source, or acquisition guidance for the ID, so meaning is only partially added beyond the schema.

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

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

States a specific verb 'Retrieves' and a specific resource 'detailed diagnostic information for a specific instance run', and even names the payload (failure error messages, file sizes). It is clearly distinguishable from the sibling get_doc_instances (which lists instances), though it doesn't explicitly name that sibling.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The phrase 'for a specific instance run' only implies you must already know an instance_id, leaving the agent to infer that a listing call must precede it.

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

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

With no annotations, the description carries the entire behavioral burden. It implies a read-only retrieval and hints at a precondition ('constrained' parameter), but says nothing about auth/session requirements, what happens when a parameter is unconstrained or invalid, or any limits — a significant gap for a zero-annotation tool.

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity is partly a symptom of missing content rather than disciplined editing.

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

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

An output schema exists, so return values need not be explained, but for a tool with two fully undocumented parameters and no annotations, the description omits the prerequisite workflow and semantics needed to call it correctly.

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

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

Schema description coverage is 0%, so both webi_doc_id and parameter_id are undocumented anywhere. The description only loosely implies the resource hierarchy ('Webi document' + 'prompt parameter'), adding no format, ID-source, or type detail the agent needs to supply valid 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?

States a specific verb ('Retrieves') and resource ('List of Values for a constrained prompt parameter in a Webi document'). It is clearly distinct from sibling list tools like get_doc_parameters or get_variables, though it does not explicitly name those siblings for contrast.

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

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

No when-to-use guidance and no named alternatives. It never says that parameter_id must first be obtained from get_doc_parameters, nor how this differs from simply listing a document's parameters, leaving the agent to infer the workflow.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the max_rows cap and the reason for it (protecting LLM context windows), plus the return shape. It omits whether this is purely a cached read, whether a refresh is required first, and what happens when the element is not a table/chart or when the row count exceeds the cap.

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

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

Three short sentences, front-loaded with the core action, then the cap behavior, then the return shape. Every sentence earns its place with no filler.

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

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

An output schema exists, so the return explanation is arguably redundant but harmless. However, for a 3-required-param tool at 0% schema coverage with no annotations, the description leaves the identifier parameters and the acquisition chain for those IDs unexplained, which is a meaningful gap.

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

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

Schema description coverage is 0%, so the description must compensate. It explains only max_rows (default 1000); webi_doc_id, report_id, and element_id — all three required — are left entirely undocumented, so an agent gets no help on where those identifiers come from or their expected format.

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

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

The description states a specific verb and resource: it extracts structured tabular data rows from a table or chart block in a report tab. This is clear enough to distinguish it from metadata-oriented siblings like get_report_elements, though it never names those siblings explicitly.

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

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

No when-to-use guidance is given. The reader must infer that element_id comes from a listing tool such as get_report_elements and that this tool is the data-retrieval step after get_reports/get_report_elements. No alternatives, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Lists" implies a non-mutating read, but nothing is said about authentication/session requirements, permissions on the referenced document, pagination, or whether the list is truncated. For a tool with zero annotation coverage this leaves the behavioral profile largely undisclosed.

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

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

A single tight sentence with the action front-loaded and the scope in a clarifying parenthetical. No filler or repetition. It is efficient, though the brevity is partly a function of the information that is missing rather than of tight editing.

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 existence of an output schema means return values need not be described, and the tool's operation is simple, so a one-liner is close to sufficient. However, the undisclosed relationship between the two required IDs and the lack of differentiation from get_report_element_data leave an agent with real ambiguity about correct invocation.

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

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

Schema description coverage is 0%, so neither webi_doc_id nor report_id is documented in the schema. The description never mentions either parameter, leaving the containment relationship between document and report, and the expected ID formats, completely unexplained. It does not compensate for the coverage gap.

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

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

States a specific verb ("Lists") and resource ("visual and data elements (tables, charts, sections)") with the scoping detail "inside a report sheet/tab". A parenthetical enumeration makes the scope concrete. It stops short of distinguishing itself from the close sibling get_report_element_data, which an agent must infer from the name alone.

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

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

There is no when-to-use guidance and no mention of alternatives such as get_reports or get_report_element_data. The context of use is only weakly implied by the phrase "inside a report sheet/tab". Nothing tells the agent when this tool is the right choice versus pulling element data directly.

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. 'Lists' implies a safe read, and it discloses the shape of the result (report IDs and tab names), but it says nothing about permissions, failure modes, or behavior on an invalid document ID.

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

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

A single front-loaded sentence with zero filler; the parenthetical return summary adds useful information rather than repeating the name.

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

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

For a simple one-parameter listing tool with an output schema, the essentials of what it returns are covered. The gaps are the unexplained required document ID and the absence of any routing guidance among the many report-related siblings.

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

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

Schema description coverage is 0% and the description never explains webi_doc_id — where it comes from, its format, or that it is required. With one undocumented parameter, the description fails to compensate for the schema gap.

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

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

States a specific verb (Lists) and resource (sheets/tabs in a Web Intelligence document), and even names the returned fields (report IDs and tab names). It is clear enough to distinguish from get_report_elements/get_report_element_data, though it never explicitly contrasts itself with those siblings.

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

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

Usage is only implied: you would call this to enumerate the tabs of a document before drilling into elements. There is no explicit when-to-use, no prerequisite (e.g. that a valid webi_doc_id must first come from get_documents), and no named alternative.

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 disclosure burden. It indicates a read operation ('Retrieves') but does not mention permissions, rate limits, error conditions, or any behavioral traits; output schema covers return values but not safety 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?

A single, front-loaded sentence with no wasted words. It is appropriately sized for a simple getter and easy to parse.

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

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

For a low-complexity lookup with one required parameter and an output schema, the description is minimally adequate. It identifies what is returned but omits parameter semantics and usage guidance, leaving the agent with some inference.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented universe_id parameter. It only implies that a Universe is involved, adding no format, syntax, or validation detail beyond what the parameter name already suggests.

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

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

States a specific verb ('Retrieves') and resource ('Data Connection ID associated with a Universe'). It is distinguishable from siblings like get_universe_details or get_universe_structure. However, it does not explicitly name alternatives, so a 4 rather than 5.

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

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

No explicit when-to-use, prerequisites, or alternative tools are provided. The phrase 'associated with a Universe' implies it requires a universe context, but there is no guidance on when to choose this over get_universe_details or other sibling getters.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about read-only semantics, permission/auth requirements, or failure behavior for a bad or unknown universe id. It hints at the entity's identifying fields but adds little beyond that.

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

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

One front-loaded sentence with no filler; the core action and target lead the sentence. Slightly dense parenthetical, but nothing wasted.

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

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

An output schema exists, so return-value detail is excused, and a one-param read getter doesn't demand much. Still, the description omits the id's accepted format and any routing hint versus the several sibling universe tools, which is a real gap for a family this crowded.

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

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

Schema description coverage is 0% for the single universe_id parameter, and the description does not explain what form that id takes (CUID, name, or engine-qualified identifier) or whether it is case-sensitive. The mention of 'unx'/'unv' engine types is entity trivia rather than parameter guidance.

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

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

States a specific verb (Retrieves) and resource (detailed metadata of a specific Universe), and the parenthetical clarifies the entity's identity fields (engine type, name, CUID). It implicitly separates itself from the list-style sibling get_universes by emphasizing 'a specific Universe', though it never names get_universe_structure or get_universe_related_reports as distinct alternatives.

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

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

The description offers no when-to-use guidance, no prerequisites, and no indication of when an agent should pick this over get_universes, get_universe_structure, or get_universe_related_reports. Usage is only inferable from the name and the single required id.

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 implies a read-only discovery operation through 'Queries' and 'discover', and lists returned fields, but it does not explicitly state read-only safety, absence of side effects, required permissions, or rate limits.

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

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

Two tight sentences with the core purpose front-loaded and no wasted wording. Every sentence contributes directly to understanding the tool's scope and output.

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

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

For a one-parameter read tool with an output schema, the description covers purpose and return fields adequately. However, it omits usage guidance versus numerous sibling tools and provides no parameter semantics for universe_id, leaving gaps an agent must infer.

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

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

Schema description coverage is 0% for the single required parameter universe_id. The description only mentions 'a specific universe', adding minimal meaning about what universe_id represents, its format, or where to obtain it.

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

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

The description uses a specific verb ('Queries the CMS to discover') and a precise resource ('all Web Intelligence reports built on top of a specific universe'). It clearly differentiates from generic siblings like get_reports or get_webi_docs by tying the query to a universe, though it does not explicitly name alternatives.

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

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

No when-to-use guidance or alternatives are provided. It states what the tool does but does not tell the agent when to prefer it over get_reports, get_webi_docs, or get_universe_details, nor any prerequisites such as needing a valid universe ID from get_universes.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the scope constraint (only published universes, both UNX and UNV) and the returned fields, but says nothing about authentication requirements, result volume/pagination, or failure behavior for a list operation that could be large.

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

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

Two short sentences, front-loaded with the action and scope. The second sentence restates return fields that the output schema already documents, so it is slightly redundant, but it costs little and adds no noise.

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

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

For a zero-parameter list tool with an output schema, the description covers what is needed: what is retrieved, which subtypes, and what the response contains. The remaining gap is the absence of routing guidance relative to the many sibling get_universe_* tools.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics to clarify. Schema description coverage is 100% and the schema is an empty object, matching the description's claim that no filtering input is accepted.

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

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

States a specific verb and resource ("Retrieves all published Universes") plus the artifact subtypes (UNX and UNV), so the agent knows exactly what this returns. It does not name or distinguish itself from siblings like get_universe_details or get_universe_structure, which is the only thing keeping it from a 5.

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

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

The word "all" implies this is the enumeration entry point and that filtering is not supported, which is weak implied guidance. There is no explicit statement of when to prefer this over get_universe_details, get_universe_structure, or get_universe_related_reports, and no prerequisites (e.g., login) are mentioned.

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

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

With no annotations, the description carries the full behavioral burden, and it discloses little beyond 'Retrieves' (implying read-only) and the REST path. It says nothing about required authentication, rate limits, response size, or whether the structure is cached/expensive to fetch.

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

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

A single well-formed sentence that front-loads the action and resource before the implementation detail (REST path). Nothing is wasted, though it is slightly compressed 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?

An output schema exists, so return-value explanation is not required, and the tool is simple (one parameter, read-only retrieval). What remains missing is routing versus sibling universe tools and parameter format, which is a minor gap for a single-call getter.

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

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

Schema coverage is 0%, so the description must compensate, and it only partially does by embedding {id} in the /sl/v1/universes/{id} path, hinting that universe_id is the universe identifier. It adds no format, source, or lookup guidance for the single required 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 verb 'Retrieves' plus the specific resource 'complete business layer hierarchy (classes, dimensions, measures, attributes) of a universe' tells an agent exactly what comes back. It is distinguishable in content from siblings like get_universe_details, but it never explicitly contrasts with them, keeping it just short of a 5.

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

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

Usage is only implied by the content fetched; there is no statement of when to prefer this over get_universe_details or get_universe_connection_id. No prerequisites or exclusions are given, so it lands at the minimum-viable level.

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

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

No annotations are provided, so the description carries the burden, but 'retrieves' clearly signals a read-only operation and 'full profile properties' indicates the scope is the complete record rather than a partial projection. It says nothing about required permissions, behavior for an unknown/invalid user_id, or rate limits, so it is adequate but thin for a no-annotation tool.

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

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

A single front-loaded sentence with no filler; the verb and resource come first. It is efficient, though the terseness borders on under-specification rather than optimal density.

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

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

An output schema exists, so return values need not be explained, which reduces the burden. However, for a tool sitting among many user-related siblings, the description omits selection guidance and any error behavior for an unknown ID, leaving gaps an agent would want covered.

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

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

Schema description coverage is 0%, so the description must compensate, and it only identifies the parameter semantically as 'a specific user ID' without specifying the expected format (numeric ID, login name, GUID, etc.). That is a real gap, though the identifier's meaning is at least conveyed.

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

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

States a specific verb (retrieves) and resource (full profile properties of a user), and the phrase 'a specific user ID' implies single-record lookup, which contrasts implicitly with the list-oriented sibling get_users. It does not explicitly name or differentiate itself from siblings like get_user_groups or get_users, so it stops short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (get_users for lists, get_user_groups for group membership). The agent must infer the context from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation and adds one useful behavioral detail (member counts are returned), but says nothing about pagination behavior despite 'all' in the description, nor about permissions or whether the result set is truncated.

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

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

A single, well-formed sentence with no waste. The scope and payload are front-loaded, though it is arguably too terse given the undocumented pagination parameters.

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

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

An output schema exists, so return-value explanation is not required. However, with no annotations and 0% parameter coverage, the description leaves the paging contract and read-only safety profile unstated, which is a meaningful gap for an agent calling this tool.

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

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

Schema description coverage is 0% with two parameters (page, pagesize) that are completely undocumented in both schema and description. The description's claim of retrieving 'all' groups actively conflicts with the presence of paging parameters, and it does not compensate for the coverage gap.

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

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

States a specific verb and resource: retrieving all User Groups configured in the BI platform, plus the extra detail of member counts. It is distinguishable from the adjacent get_group_users sibling (which lists users within a group), though it never names or contrasts that alternative explicitly.

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

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

The description contains no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_group_users or get_user_details. An agent must infer the selection context entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Lists' implies a read operation, but nothing states pagination behavior, result limits, permission requirements, or what happens across pages, and the two paging parameters are never acknowledged.

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

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

A single efficient sentence with the verb and resource front-loaded and no filler. It is well-sized, though it spends its brevity on output fields rather than the guidance an agent most needs.

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

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

An output schema exists, so return values need not be enumerated in prose (making the parenthetical partly redundant). The main gap is the absence of any pagination guidance and the lack of annotation coverage for a list operation, leaving the agent to guess at paging behavior.

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

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

Schema description coverage is 0%, so both 'page' and 'pagesize' are undocumented in the schema, and the description does not compensate by explaining paging, defaults, or max page size. The parenthetical describes return fields rather than the input parameters.

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

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

States a specific verb (Lists) and resource (user accounts in the BI platform repository), and the parenthetical enumerates the returned fields, which helps the agent distinguish it from detail-oriented siblings. However, it never explicitly contrasts itself with get_user_details or the singular scope, so sibling differentiation is only 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as get_user_details for a single account or get_group_users for group-scoped queries. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation and scopes results to a Webi document, but says nothing about required permissions, whether the document must be open/refreshed, error behavior for invalid IDs, or result size. For a zero-annotation tool this is a significant gap.

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

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

One front-loaded sentence with no filler; the verb and scope come first. It is efficiently written, though the terseness reflects under-specification rather than optimal density.

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

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

An output schema exists, so return values need not be described. However, with no annotations and an undocumented parameter, the description leaves the agent guessing about access requirements and invocation preconditions for this read tool.

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

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

Schema description coverage is 0% and the single parameter webi_doc_id is undocumented in the schema. The description implies the ID refers to a Webi document, but adds no format, source, or validity details to help the agent supply a correct value.

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

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

Clear specific verb+resource: retrieves custom formulas and calculated variables. This distinguishes it from siblings like get_doc_parameters, get_reports, and get_report_elements, which cover different document artifacts. It stops short of explicitly naming an alternative, so 4 rather than 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of sibling tools such as get_doc_parameters or get_dp_specification. The agent must infer from the purpose alone when this tool is the right choice.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose two useful traits: results are limited to direct children (non-recursive) and only identifiers are returned. It says nothing about authentication, permissions, empty folders, or error behavior, so the disclosure is partial.

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

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

A single front-loaded sentence with no filler; the scope qualifier 'directly inside' is placed where it does the most work.

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

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

An output schema exists, so return-shape explanation is unnecessary, and the description correctly notes that only IDs come back. However, for a tool whose only parameter is undocumented at the schema level, the definition leaves an agent unsure how to supply folder_id or when this beats get_documents.

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

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

Schema coverage is 0% and there is a single required parameter, folder_id, whose description is empty. The description only implies it is a 'repository folder', leaving the expected format (numeric ID vs path) and how to obtain a valid value unaddressed.

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

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

The description gives a specific verb (Lists), resource (Web Intelligence document IDs), and scope (directly inside a repository folder), which lets an agent separate it from the broader get_documents or the detail-oriented get_doc_details. It does not name a sibling explicitly, so it stops short of a 5.

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

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

There is no statement of when to use this tool versus get_documents, get_doc_details, or get_doc_properties, all of which sit in the same namespace. The phrase 'directly inside' weakly implies non-recursive listing, but no alternative or condition is stated.

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

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

With no annotations, the description carries the full burden and does disclose real behavioral traits: it creates an enterprise session, returns an X-SAP-LogonToken, and silently falls back to .env credentials. It stops short of covering failure behavior (invalid credentials), session lifetime, or whether repeated calls create multiple sessions.

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

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

Three short sentences, front-loaded with the purpose before the session/token detail and the credential default. Every sentence contributes information an agent needs; nothing is redundant.

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

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

For a two-parameter, no-annotation login tool with an output schema (so return values need no prose), the description covers purpose, session/token effect, and credential fallback. The remaining gap is the auth/permission and failure context that a login tool would ideally state.

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

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

Schema description coverage is 0% and the schema only marks both params as nullable strings defaulting to null, so the description's explanation that omitting them triggers .env fallback adds genuine semantics for both parameters. It does not, however, clarify expected formats or error cases for bad credentials.

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

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

States a specific verb and resource ('Log in to the SAP BusinessObjects BI Platform') and adds the concrete outcome: an active enterprise session plus an X-SAP-LogonToken. This clearly separates it from siblings like logout and terminate_session, which are the inverse operations.

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 only usage guidance is the conditional 'If username/password are omitted, values from .env are used automatically,' which is really parameter behavior rather than when-to-use-this-tool guidance. There is no explicit statement about when login is required (e.g., before authenticated calls) or how it relates to logout/terminate_session.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key side effect (the active session token is invalidated, making it a state-changing call), but says nothing about idempotency, behavior when no session is active, or authentication prerequisites.

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

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

A single front-loaded sentence with the operation first and its consequence second. No filler, nothing repeated from the schema or title.

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

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

For a zero-parameter session-teardown tool with an output schema already covering return values, the description supplies what an agent needs. Only edge-case behavior (no active session, failure mode) is left unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; per the baseline for parameterless tools a 4 is appropriate. Schema coverage is 100% and the empty object is self-explanatory.

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

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

States a specific verb ('Log out') plus the resource ('SAP BusinessObjects platform') and goes further to name the observable effect ('invalidate the active session token'). This clearly separates it from the sibling 'login' and from 'terminate_session', which acts on other sessions.

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

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

Usage is only implied by the tool name and the natural session lifecycle; the description never says when to call this versus 'terminate_session', nor whether a session must exist first. No explicit when/when-not guidance is given.

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

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

No annotations are provided, so the description carries the full behavioral burden for a destructive-sounding operation. It states the effect (removes cached rows, shrinks the document) but says nothing about reversibility, whether the purged data can be re-fetched via refresh_dp, required permissions, or any side effects on dependent reports.

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

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

A single efficient sentence that front-loads the verb and resource with no wasted words. It is appropriately sized, though it is short precisely because it omits needed behavioral and parameter detail.

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

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

An output schema exists so return values need not be explained, but for an unannotated destructive mutation with two undocumented required parameters the description leaves out reversibility, permissions, and usage context. It is not complete enough for an agent to call it safely.

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

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

Schema description coverage is 0% and neither parameter is described in the schema. The description vaguely gestures at the Data Provider ('dp_id') but never explains the two required IDs, their format, or how webi_doc_id scopes the purge, so it does not compensate for the coverage gap.

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

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

States a specific verb (purges), resource (cached data rows) and target (a specific Data Provider) plus the intent (reduce document storage size). This clearly separates it from siblings like get_dp, refresh_dp, and delete_webi_doc, though it never names those alternatives.

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

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

No explicit when-to-use guidance, no preconditions, and no routing to alternatives such as refresh_dp (which presumably re-populates the cache) or delete_webi_doc. The 'to reduce storage size' clause only implies intent, it does not tell the agent when this is the right call.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one meaningful trait — the operation is scoped to a single DP and deliberately avoids recalculating the rest of the report — but says nothing about permissions, idempotency, failure behavior, or cost/latency. Return values need not be covered because an output schema exists.

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

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

A single sentence with no filler, and the scope-narrowing clause is placed immediately after the core action. Nothing is wasted and nothing needs reordering.

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 output schema covers return values, so that gap is closed. But with two required, zero-documented parameters, the description should at minimum clarify how the document and data-provider identifiers relate; that omission leaves a real hole for a mutation-style refresh tool.

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

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

Schema description coverage is 0% and both required parameters (dp_id, webi_doc_id) are undocumented in the schema. The description references 'a Data Provider' generically but never explains that dp_id identifies the provider or that webi_doc_id identifies the containing document, so an agent gets no help resolving either required argument.

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

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

States a specific verb ('Refreshes') and resource ('a single Data Provider'), plus a scoping constraint ('without recalculating the rest of the report') that effectively separates it from the sibling refresh_webi_doc. It stops short of naming that sibling, so an agent must infer the contrast rather than being told it.

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

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

The phrase 'without recalculating the rest of the report' implies the intended use case (targeted single-DP refresh rather than a full document recalc), which is useful implied guidance. However, no alternative tool is named and no conditions for when-not-to-use it are given, so the routing decision is left partly to inference.

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

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

With no annotations, the description carries the full disclosure burden. It usefully reveals that prompt answers can be supplied at refresh time, but omits key behaviors for a mutation-style call: whether the refresh persists the document, permission requirements, and whether unprompted documents refresh silently.

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

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

Two sentences, front-loaded with the action, and the example earns its length because the schema itself is opaque. Minor slack only in that the example could be tighter.

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

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

An output schema exists, so return values need not be described. However, for a mutation tool with zero annotations the description should say more about persistence, permissions, and where prompt IDs come from; as written it covers the action and one input shape but not the full call context.

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

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

Schema description coverage is 0%, so the description must compensate, and it does well for the opaque `parameters` anyOf array by giving a concrete payload example with both scalar and multi-value entries. `webi_doc_id` and the origin of prompt IDs (get_doc_parameters/get_parameter_lov) remain unexplained.

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

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

The description states a specific verb and resource ('Refreshes a Web Intelligence document'), so the operation is unambiguous. It does not, however, distinguish itself from the sibling refresh_dp (data-provider refresh) or clarify scope relative to save_webi_doc, so sibling differentiation is left to inference.

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

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

There is no explicit when-to-use guidance: nothing says when to refresh a document versus refresh_dp, nor whether the document must be opened/locked first. The conditional prompt case is mentioned, but that is behavioral detail rather than routing guidance.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly discloses that providing a name overwrites or saves as a new name, and that comments and annotations are preserved. It does not mention authentication or permissions, but the key destructive side effect is 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 two tightly written sentences with no wasted words. The two save modes are front-loaded, making the behavior easy to parse quickly.

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

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

For a two-parameter save tool with an output schema, the description is nearly complete. It covers the critical overwrite and preservation behavior. Minor gaps remain around authentication or failure behavior, but nothing essential for invoking the tool correctly is missing.

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

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

Schema description coverage is 0%, so the description must supply parameter meaning. It clearly explains the effect of webi_doc_name being omitted or specified. It does not explicitly describe webi_doc_id, but its role as the target document is strongly implied.

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

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

The description states a specific verb and resource: saving a Web Intelligence document. It also distinguishes in-place saving from Save As based on the optional parameter. It does not explicitly differentiate from siblings like refresh_webi_doc or delete_webi_doc, but the purpose is clear.

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

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

The description explains when to omit webi_doc_name (save in place) and when to provide it (Save As/overwrite). It does not mention when to use this tool versus alternatives such as refresh_webi_doc or get_webi_docs. The usage guidance is therefore implied 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 behavioral burden. It clarifies the two possible effects but says nothing about whether deactivation is reversible, whether it invalidates active sessions (a real risk given the terminate_session sibling), required privileges, or the response shape — significant gaps for an account-mutating tool.

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

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

A single sentence with the effect (enables/disables) front-loaded and the parenthetical flag mapping attached directly to it. No filler, though the sentence is terse enough that it could have spent one more clause on behavioral 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?

An output schema exists, so return values need not be described, but for a state-changing user-account tool with zero annotations the description omits consequences, reversibility, and authorization needs. An agent can call it mechanically but cannot predict the side effects.

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

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

Schema description coverage is 0%, and the description compensates for the non-obvious half by explicitly defining disabled=False as enable and disabled=True as disable. It adds nothing for user_id, though that parameter's meaning is largely self-evident from its name.

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

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

The description names a specific verb pair (enables/disables) and resource (a user account in the BI platform), which is more precise than the tool name alone. It does not explicitly distinguish itself from nearby siblings such as get_users or terminate_session, so an agent must infer the boundary.

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

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

There is no statement of when to use this tool versus alternatives, nor any prerequisite or permission context. The only usage signal is the inline mapping of the disabled flag to each outcome, which tells an agent how to call it but not when it is the right choice.

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

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

With no annotations, the description carries the full burden, and it does disclose the key trait: the operation is forced/destructive ("forcibly disconnects"). However, it says nothing about permissions required, idempotency, behavior when the session ID is invalid or already gone, or whether the user is notified — notable gaps for a destructive tool.

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

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

One front-loaded sentence with the action and target stated immediately and no filler. It is efficient, though the extreme brevity leaves no room for the operational caveats a destructive tool would benefit from.

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

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

An output schema exists, so return values need not be explained, and there is only one simple parameter. Still, for a destructive session-termination tool with zero annotations, the description omits how to acquire the session/connection ID, permission requirements, and failure behavior.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter. It adds the meaning "connection ID" for the target, but the schema names the field session_id while the description says "connection ID", creating ambiguity about whether these are the same identifier (a sibling get_universe_connection_id suggests they may be distinct concepts).

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

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

States a specific verb pair ("forcibly disconnects and terminates") and a specific resource ("active user session"), which is enough to separate it from read-only siblings like get_active_sessions. The qualifier "by connection ID" is clear about the targeting key, though it doesn't name any sibling explicitly.

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

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

There is no when-to-use guidance, no prerequisite (e.g., obtaining the ID from get_active_sessions), and no mention of how this differs from logout for ending a session. The agent must infer the workflow entirely from sibling names.

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