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

No annotations are provided, so the description carries the full burden. It discloses that explicit confirmation is required and that only non-default groups are targeted, which is useful. However, it does not mention what happens if confirmation is false, whether the operation is idempotent, or any permission requirements. These gaps were not addressed.

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 one concise sentence that front-loads the core action and constraint. Every word contributes, with no filler or redundancy.

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

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

For a tool with three required parameters, no annotations, and no output schema, the description covers the core purpose and one behavioral condition. However, it omits details about return values, failure cases, and prerequisites (e.g., group must exist). It is minimally sufficient but not comprehensive.

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

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

With 0% schema description coverage, the description must compensate. It maps the action to groupId, userId, and confirm conceptually, but it does not explain each parameter individually. The phrase 'explicit confirmation' does imply the confirm boolean, but it does not clarify that confirm must be true or describe the exact format of user/group IDs.

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

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

The description clearly states the action ('Add a user') and the target resource ('a non-default group'). It also includes a key condition ('after explicit confirmation'), distinguishing it from other group-related tools. The verb and resource are specific and unambiguous.

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

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

The description implies when to use the tool: for adding a user to a non-default group with explicit confirmation. However, it does not explicitly mention alternative tools (e.g., remove_group_user) or specify when not to use it beyond the non-default constraint. Usage context is implied but not fully elaborated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that the update must have been previewed, which is a useful workflow constraint, but it doesn't mention side effects, reversibility, overwriting behavior, or error conditions. For a mutation tool, this is a notable gap.

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

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

The description is a single 8-word sentence that is front-loaded with the verb and states the exact object being acted upon. There is zero redundancy or filler.

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

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

For a simple one-parameter apply operation, the description covers the core prerequisite but omits details like return values, success/failure behavior, or confirmation steps. Given the lack of an output schema and annotations, a bit more context would improve completeness, but the basic use case is understandable.

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 previewId is not described in the text, and schema coverage is 0%. However, the word 'previewed' in the description and the parameter name make the meaning reasonably clear—it is the ID from a preview call. The description doesn't explicitly link previewId to a return value from preview_column_formatting_update, but the intent is inferable.

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

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

The description uses the specific verb 'apply' with the resource 'previously previewed column formatting update,' clearly distinguishing it from sibling tools like apply_column_update (general column update) and apply_view_formatting_update. The object being acted upon is precise and unambiguous.

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

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

The phrase 'previously previewed' strongly implies a prerequisite: the update must have been previewed first, which points to the companion preview_column_formatting_update tool. While it doesn't explicitly name the alternative or state when not to use it, the contextual guidance is clear.

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

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

No annotations are provided, so the description carries the full burden. It reveals a prerequisite (the update must be previewed) but does not disclose effects, permissions, reversibility, or response format. For a mutation 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?

The description is a single sentence with no filler, front-loaded with the verb and resource. It is appropriately sized for the tool's low 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?

With one parameter, no output schema, and no annotations, the description adequately covers the core action and prerequisite but omits return behavior and error scenarios. It is minimally viable but leaves clear gaps.

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

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

The single previewId parameter has no schema description, and schema coverage is 0%. The description adds minimal context by tying the parameter to a 'previously previewed' update, but it does not explain how to obtain the previewId or what format it takes beyond the schema's minLength.

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 ('Apply') and resource ('column update'), with a qualifier ('previously previewed') that clearly distinguishes it from sibling tools like preview_column_update and apply_view_update. It states exactly what the tool does.

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

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

The phrase 'previously previewed' clearly implies that preview_column_update must be called first, giving contextual usage guidance. However, it does not explicitly name alternatives or state when not to use this tool, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It only states the action without disclosing behavioral traits such as whether the update is permanent, what permissions are needed, whether it can be undone, or any side effects. This is minimal value beyond the tool name.

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

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

The description is a single, focused sentence with no fluff. It is appropriately concise, though under-specified; however, that under-specification is a completeness issue, not a conciseness one.

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

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

Given the lack of annotations and output schema, the description is too sparse to provide complete context. It omits parameter guidance, workflow prerequisites, side effects, and return expectations, leaving the agent to infer too much from the tool name and 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 schema has one parameter (previewId) with 0% description coverage. The description does not explain what previewId is, where to obtain it, or its format. With zero coverage, the description should compensate but does not add any parameter-level meaning.

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

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

The description clearly states the action ('Apply') and the resource ('site group update'), and specifies it is for a 'previewed' update, distinguishing it from siblings like create_group, delete_group, and apply_view_update.

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 'previewed' implies this tool should be used after a preview operation, but the description does not explicitly state prerequisites, when to use versus alternatives, or any exclusion criteria. Usage guidance is only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely states 'Apply...' without explaining that this is a mutating operation, whether permissions are required, if it is reversible, or what happens when applied. The lack of safety or side-effect details 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?

The description is a single, short sentence with no redundant information. It is front-loaded with the verb 'Apply', making it immediately clear what action the tool performs. There is zero waste.

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

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

Despite the tool's simplicity, the description lacks essential context: it does not state what applying entails, how to obtain the previewId, what the success/failure behavior is, or any side effects. With no annotations and no output schema, the agent is left without sufficient guidance 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?

The schema has one required parameter (previewId) with 0% description coverage. The description hints at the concept of 'previously previewed' but does not explicitly explain that previewId is the identifier returned from preview_item_update. The description adds minimal context beyond the schema and does not compensate for the lack of parameter documentation.

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

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

The description clearly states the action ('Apply') and the specific resource ('previously previewed item update'), distinguishing it from sibling tools like apply_view_update or preview_item_update. The verb+resource combination is unambiguous and effectively communicates the tool's role.

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

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

The phrase 'previously previewed' implies the tool must be used after preview_item_update, providing clear context. However, it does not explicitly name alternatives or exclusions, such as 'use apply_list_update for list updates' or 'do not use this for creating items.'

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and target, omitting side effects, reversibility, required permissions, or what happens upon success/failure—a notable gap for a mutation tool.

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

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

The description is a single, direct sentence that efficiently conveys the action and target. No unnecessary words or repetition.

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

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

The tool is a mutation with no annotations, no output schema, and minimal parameter documentation. The description fails to explain the prerequisite workflow (e.g., calling preview_list_item_permission_update first), error conditions, or the effect of applying changes, leaving the agent without sufficient context for reliable 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 the description does not explain the previewId parameter's origin or format. The only hint is the word 'previewed,' which insufficiently compensates for the lack of schema documentation.

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

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

The description uses the specific verb 'apply' and clearly identifies the resource as 'previewed permission changes to one list item.' This distinguishes it from sibling tools like apply_list_permission_update (list-level) and preview_list_item_permission_update (preview action).

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 term 'previewed' implies the tool must be used after a preview operation, but the description does not explicitly state when to use this tool versus alternatives like apply_list_permission_update. There is no mention of exclusions or conditions.

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

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

No annotations are provided, so the description carries the full burden of disclosure. It indicates a commit/apply action, but does not disclose side effects, reversibility, required permissions, or failure behavior. For a mutation 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?

The description is four words long and immediately communicates the core action. It contains no filler or redundant information, making it highly concise and front-loaded.

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

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

As a mutating tool with no annotations, no output schema, and a minimal description, it lacks essential context such as prerequisites (must have a previewId), the fact that changes are permanently committed, and any post-conditions. This is incomplete for a tool that applies permission changes.

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

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

The schema has one required previewId with no description (0% coverage). The description's 'previewed' helps connect the parameter to a preview ID, adding some meaning beyond the raw schema. However, it does not explain where to obtain the previewId or what format to expect, leaving the parameter somewhat underspecified.

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

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

The description clearly states 'Apply previewed list permission changes' with a specific verb ('apply') and resource ('list permission changes'). It distinguishes from sibling tools like apply_list_update and apply_item_permission_update by specifying 'list permission'. The word 'previewed' adds scope and links to the preview step.

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

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

The description implies usage after previewing list permission changes via the word 'previewed', but it does not explicitly state when to use this tool versus alternatives or mention exclusions. It lacks guidance on prerequisites or the relationship to preview_list_permission_update.

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

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

Since there are no annotations, the description must disclose behavioral traits, but it only states 'apply', implying a mutation without any details on side effects, reversibility, permissions, or the fate of the preview. This is a significant transparency gap for a commit operation.

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

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

The description is a single sentence that is concise and front-loaded. Every word earns its place; there is no fluff or redundancy.

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

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

For a mutation tool with no output schema and sparse annotations, this description is too thin. It fails to mention return values, preconditions, or what exactly happens when the update is applied, leaving the agent without sufficient context 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?

The description adds minimal meaning to the single parameter 'previewId' by indicating it refers to a previously previewed update. However, it doesn't explain how to obtain it or what its format implies beyond the schema's minLength constraint. For a simple one-parameter tool, this is adequate but not enriching.

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

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

The description clearly states the action (apply) and the resource (a previously previewed list update), which distinguishes it from sibling tools like apply_item_update or apply_column_update. It is specific and unambiguous, though it doesn't elaborate on what a 'list update' includes.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention that the previewId comes from preview_list_update, nor does it exclude using it for other entity updates. There is no context for when this tool is 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 must disclose behavioral traits but only mentions a default API preference. It does not state whether the operation is destructive, requires special permissions, is reversible, or what response to expect. The 'preferring SharePoint REST' detail adds a small nugget of behavior but is far from sufficient for a mutation tool.

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

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

The description is one short sentence with no wasted words. It front-loads the primary action and resource, then adds the notable API preference. This is appropriately concise for a tool with a simple schema.

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

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

Despite the simple schema, the tool mutates a page layout and has no output schema or annotations. The description fails to explain the workflow (e.g., that a preview ID from preview_page_layout_update is required), what happens after applying, or any side effects. A more complete description would cover the preview-apply relationship and expected outcome.

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, but it provides little detail. 'previewId' is only weakly implied by 'previewed', and 'preferApi' is essentially restated by 'preferring SharePoint REST by default', which duplicates the schema default. It adds minimal value beyond the input schema.

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

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

The description uses a specific verb 'Apply' and identifies the resource as 'previewed page canvas layout update', clearly distinguishing it from sibling tools like apply_view_update. It does not explicitly differentiate from other apply tools, but 'page canvas layout' narrows the scope enough. The mention of 'previewed' also sets it apart from preview-related tools.

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

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

The word 'previewed' implies this tool should be used after a preview operation, but it does not explicitly state when to use it versus alternatives or when not to use it. No alternatives are named, and the default API preference is mentioned but not explained in terms of when to switch. Usage is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explain the effects of applying the update (e.g., whether it overwrites existing formatting, is reversible, requires permissions, or returns a result). The only hint is the 'previously previewed' precondition, which adds minimal context.

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

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

The description is a single, concise sentence that front-loads the action verb and resource. It contains no wasted words and is easy to scan.

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

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

The tool is simple (one parameter, no output schema), but the description does not fully elaborate the workflow. It implies a prior preview step but never explicitly states to use preview_view_formatting_update, nor does it describe any side effects or return values. Overall, it is minimally viable but leaves gaps in operational 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?

The schema has only one parameter, previewId, with no description, so schema coverage is 0%. The description's 'previously previewed' gives a vague hint that the previewId must come from a preview operation, but it does not specify where to obtain it or that it is the ID returned by preview_view_formatting_update. This is insufficient compensation for the lack of schema descriptions.

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

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

The description states a specific action ('Apply'), a clear resource ('view formatting update'), and a scope ('previously previewed'). It distinguishes itself from sibling tools like preview_view_formatting_update and apply_view_update by emphasizing that the update must have been previewed first.

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 'previously previewed' gives clear context that this tool should be used after a preview operation, implying a workflow. However, it does not explicitly name the alternate tool to use for previewing (preview_view_formatting_update) or exclude other apply tools, so it stops short of full guidance.

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

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

No annotations are provided, so the description carries the full burden. 'Apply' implies a mutation, but there is no disclosure of effects, reversibility, prerequisites (beyond having a preview), or return value. This is a significant transparency gap for a mutation tool.

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

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

The description is a single, focused sentence with no unnecessary words. It is front-loaded and efficiently conveys the core action, though it could be expanded to include more behavioral detail without becoming verbose.

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

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

With no output schema and no annotations, the description should explain what happens on success, error cases, or relationship to preview. It does none of this. For a mutation tool, this is inadequate for an agent to understand the full 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 does not mention the parameter. The parameter name 'previewId' gains some meaning from the phrase 'previously previewed,' but no format, source, or validation details are provided beyond the schema's minLength. The description fails to compensate for low schema coverage.

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

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

The description clearly states a specific action ('apply') and a specific resource ('previous previewed view update'), distinguishing it from preview_view_update and other apply_* tools by the 'previously previewed' qualifier.

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 'previously previewed' gives clear context that this tool is for applying updates only after a preview has been created, implying a prerequisite. It doesn't explicitly name alternatives or exclusions, but the intended usage is clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only restates the action. It does not mention the destination of the copy, whether a new item is created, permissions required, or any side effects.

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

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

The description is extremely concise, front-loaded with the action, and contains no filler. While it is terse, it does not waste words; the brevity is a mild trade-off against completeness.

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

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

With no output schema, no annotations, and a three-parameter signature, the description is too thin to be operationally complete. It does not explain the copy destination, return value, or error behavior, which are necessary 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 the description adds no meaning to the three required parameters. The role of parentId as the target location is not explained, leaving the agent to guess parameter semantics.

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

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

The description uses a specific verb 'Copy' and resource 'a drive item', clearly identifying the operation. It does not explicitly distinguish from the sibling move_drive_item, but 'copy' implies a duplicate rather than relocation.

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 guidance on when to use copy_drive_item versus move_drive_item or other related tools. There are no alternatives, prerequisites, or context cues provided.

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

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

With no annotations, the description must fully disclose behavioral traits. It only says 'create' with no detail about immediate effects, required permissions, error behavior (e.g., if column already exists), or response format. This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence with no unnecessary words. It is front-loaded with the action and resource, but it is so brief that it lacks substance, which is penalized 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?

The tool involves a nested 'definition' object with no schema detail, no output schema, and no behavioral or usage context. The description is entirely inadequate for an agent to correctly construct a valid column creation request.

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

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

The schema has 0% description coverage, and the description mentions neither 'listId' nor 'definition'. It fails to clarify what the 'definition' object should contain or how listId is used, leaving parameter semantics entirely 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 clearly states the action ('Create a column') and the target resource ('a SharePoint list'). This specific verb+resource pairing distinguishes it from sibling create tools for lists, items, views, groups, and other resources.

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

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

There is no guidance on when to use this tool versus alternatives like preview_column_update or apply_column_update. The description provides no context about prerequisites, such as needing an existing list, nor does it mention any exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a mutation ('Create') but does not state required permissions, side effects, default behavior, or error conditions. This is a significant gap for a write operation.

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

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

The description is compact and front-loaded, but it is under-specified, providing barely more than the tool name itself. It is not a tautology, but it lacks substantive content, making 'appropriate size' debatable.

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

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

With no output schema, no annotations, and zero parameter descriptions, the description is inadequate for a tool with three required parameters. It does not explain return values, error behavior, or how the parameters relate to the resulting folder, leaving many critical details 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%, and the description does not mention any of the three required parameters (name, driveId, parentId). The agent receives no semantic help for correctly supplying these parameters.

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

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

The description uses a specific verb ('Create') and a specific resource ('drive folder'), which clearly distinguishes it from sibling tools that create other resource types (lists, items, columns, views, groups, pages). This is a clear and unambiguous purpose.

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

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

The description provides no guidance on when to use this tool versus alternative workflows or tools. It does not mention any prerequisites, exclusions, or preferred scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing any side effects, required permissions, mutation semantics, or the structure of the definition object. This is a significant transparency gap for a create operation.

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

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

The description is a single sentence with no wasted words, making it concise. However, it is under-specified to the point of being terse; the conciseness does not improve usability given the lack of essential details.

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

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

The tool has a free-form definition object, no output schema, and no annotations, yet the description provides no context about the group definition, expected properties, or behavior. Sibling tools suggest a broader group management workflow, but this description gives no indication of how to create a valid group.

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

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

The input schema has a single 'definition' parameter with no description and 0% schema coverage, and the tool description does not mention this parameter at all. The agent is left without any clue about what the definition object should contain or how it maps to a SharePoint group.

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 'Create a SharePoint site group' clearly identifies the action (create) and the resource (SharePoint site group). It is concise and unambiguously distinguishes from sibling tools like get_group, update_group, and delete_group.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as the need for an active site or the relationship to preview/apply update operations for groups. There is no stated context for creating a group.

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

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

No annotations are present, so the description must disclose behavior. It only says 'Create' without stating side effects, required permissions, return values, or failure behavior for a mutating operation. This leaves the agent without critical operational context.

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

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

The description is a single, efficient sentence that front-loads the action. It is concise and not verbose, though it omits helpful detail. It earns its place by stating the resource and operation.

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

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

With no output schema and no annotations, the description must cover expected outputs or side effects. It only states what the tool does, not what the agent should expect in response (e.g., created item ID), making it incomplete for confident 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 the description does not compensate. It fails to explain that 'fields' holds item properties and 'listId' identifies the target list, leaving parameter usage entirely 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 clearly states the tool creates an item in a SharePoint list, using a specific verb and resource. This distinguishes it from sibling tools like create_list or update_item, as it is the creation operation for items.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not specify that it's for new items, mention any prerequisites, or exclude any scenarios. No alternative tools are referenced.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action itself. It does not mention failure modes, permission requirements, effects on the active site, or the structure of the 'definition' parameter, which is critical for a mutation tool.

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

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

The description is a single concise sentence that is front-loaded with the core purpose. While it lacks detail, it is efficiently worded and does not contain unnecessary fluff, though the under-specification is addressed 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?

Despite having only one parameter, the description is incomplete for real-world use. It does not explain the definition parameter, return value, error handling, or side effects, and no output schema is provided to fill the gap. The tool's complexity may be moderate, but the description offers little beyond the tool name.

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

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

The only parameter 'definition' has no schema description (0% coverage) and the description does not mention it at all. The agent receives no clues about required fields, formatting, or acceptable values for this unstructured object, making it essentially impossible to construct a valid request.

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

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

The description clearly states the tool creates a list in the active SharePoint site, with a specific verb and resource. It distinguishes from sibling tools like create_item, create_column, and create_view by explicitly naming the target 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, such as checking for existing lists, or any exclusions or alternative approaches like previewing changes before creation.

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

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

With no annotations, the description must supply all behavioral transparency. The only disclosed behavior is the preference for SharePoint REST by default, which is a useful hint about the preferApi parameter. However, it does not explain what happens on creation (e.g., location, draft status, return values) or any side effects, leaving significant gaps for a creation tool.

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

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

The description is a single sentence that is front-loaded with the core action. The API preference clause is brief and adds relevant technical context. Every word contributes value, with no filler or redundant content.

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

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

Given the tool's complexity—a nested `definition` object, no output schema, and no annotations—the description is severely incomplete. It lacks any explanation of the definition structure, site context requirements, or expected result. An agent would be left guessing the format of the required parameter, making the tool nearly unusable without external documentation.

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. The phrase 'preferring SharePoint REST by default' adds meaning to the preferApi parameter by clarifying its default behavior. However, the required `definition` object is not described at all—no hints about its shape, required fields, or how it defines a modern page.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Create a modern page'. This distinguishes it from sibling tools like get_page, publish_page, and preview_page_layout_update, which handle different operations. The qualifier 'modern' adds specificity beyond a generic page creation.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any recommended contexts, exclusions, or comparisons to related tools such as create_list or apply_page_layout_update. The API preference clause is a technical detail, not a usage guideline.

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

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

There are no annotations, so the description must carry the burden of behavioral disclosure. It only states that a view is created, but does not mention side effects, permissions, reversibility, or what happens to existing data. For a mutation operation, this is insufficient.

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

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

The description is a single sentence with no filler or redundancy, making it concise. However, it is underspecified, which detracts from its usefulness. It earns a 4 because it is well-structured and to the point, though it could be richer.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description should provide substantial context. It only states the basic action and omits return values, prerequisites, or how the 'definition' object should be formed. This is incomplete for a creation tool in a complex SharePoint environment.

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 does not explain the parameters. 'listId' and 'definition' are left entirely to the schema, and 'definition' is particularly vague. The description provides no additional meaning beyond the property names, failing to compensate for the lack of schema descriptions.

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

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

The description clearly states the tool's function: 'Create a view in a SharePoint list.' It uses a specific verb ('create') and resource ('view in a SharePoint list'), which distinguishes it from siblings like delete_view or apply_view_update. The purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that create_view is for new views, whereas apply_view_update is for modifying existing ones, nor does it mention any prerequisites such as an existing list. This is a clear gap in usage context.

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

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

There are no annotations, so the description carries the full burden. It discloses the core action 'delete a column' but provides no additional behavioral context such as irreversibility, data loss, permissions, or what happens with an invalid preview. This is a significant gap for a destructive operation.

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

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

The description is a single, concise sentence that states the essential information without any wasted words or redundant details.

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

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

For a single-parameter deletion tool with no output schema, the description is minimally adequate but lacks detail on the preview flow and the meaning of 'valid preview'. Given the sibling tools, an agent can infer the workflow, but the description alone doesn't fully contextualize the operation.

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

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

The schema has no description for previewId (0% coverage). The description adds some meaning by tying the parameter to the concept of a 'valid preview', but it doesn't explain how to obtain it or what 'valid' means, leaving the parameter only partially elaborated.

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

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

The description clearly states the action (delete) and the resource (a column), and the phrase 'using a valid preview' distinguishes this from the sibling tool preview_delete_column, which is for previewing the delete.

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

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

The description implies the prerequisite of having a valid preview, which indicates when to use this tool (after a preview is created). It doesn't explicitly name alternatives or exclusions, but the context is clear enough given the sibling preview_delete_column.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Delete' which is tautological with the tool name and provides no additional traits such as irreversibility, confirmation requirements, cascade effects, or error handling, leaving the agent without critical 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?

The description is a single, front-loaded sentence of five words, making it highly concise and easy to parse. While it is not a tautology, it borders on under-specification, but this is more of a completeness issue than a conciseness issue.

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

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

Given the tool's destructive nature, lack of annotations, and absence of an output schema, the one-sentence description is entirely inadequate. It fails to explain the relationship to preview_delete_drive_item, any prerequisites, return values, or behavioral caveats, making it unsafe for an agent to use 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?

The input schema has 0% description coverage and the description does not elaborate on previewId. The phrase 'previewed drive item' aligns with the parameter name, but it does not explain how to obtain the previewId, its lifecycle, or any constraints beyond the schema's minLength.

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 identifies the action ('Delete') and the resource ('drive item') clearly, and the qualifier 'previewed' distinguishes it from generic delete operations and hints at the preview/apply pattern seen in sibling tools like preview_delete_drive_item. However, it does not explicitly state that this is the apply step following a preview, which leaves slight ambiguity.

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

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

The description implies it should be used on a previously previewed item but does not explicitly explain when to use it versus alternatives like move_drive_item or copy_drive_item, nor how it relates to preview_delete_drive_item. There is no exclusionary guidance or context about the required preview state.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It states the action and the confirmation requirement but does not disclose that deletion is permanent, whether it can be undone, or what permissions are needed. This is a significant gap for a destructive operation.

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

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

The description is a single concise sentence, front-loaded with the action. It contains no fluff and every word adds value: 'non-default' and 'explicit confirmation' are essential constraints.

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 destructive tool with no annotations and no output schema, the description is too minimal. It does not mention success/failure behavior, error conditions, or whether the deletion is permanent. The sibling tools include preview delete operations for other resources, but no such preview exists for groups, so the description should clarify the immediate effect.

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 description must compensate. The phrase 'explicit confirmation' adds meaning to the 'confirm' parameter, but it does not explain 'groupId' beyond the resource name. The description partially compensates but leaves one parameter undocumented semantically.

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 ('Delete') and resource ('non-default site group'), clearly stating the tool's function. It distinguishes from siblings like 'get_group' or 'create_group' by indicating it's a deletion operation and includes a constraint ('non-default') and a requirement ('explicit confirmation').

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 when to use: only for non-default groups, which excludes default groups. It also mentions 'explicit confirmation' as a user action required. However, it does not explicitly compare to alternative actions like previewing the delete or applying group updates, though the unique delete verb makes the context clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that deletion requires a valid preview, which is a notable behavior, but it does not explain what constitutes a valid preview, whether deletion is permanent, or any potential side effects. For a destructive operation, this is limited transparency.

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

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

The description is a single, concise sentence that immediately states the action and the key requirement. There is no filler or redundant information, and it is front-loaded with the verb and resource. It is appropriately sized for a tool with one 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?

Given the simplicity of the tool (one param, no output schema, no annotations), the description is too sparse to be fully self-contained. It does not mention how to obtain a valid preview, nor does it explicitly connect to preview_delete_item. An agent might struggle to know the correct sequence, especially with many sibling preview/apply/delete 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 schema only defines previewId as a string with minLength 8 and no description, so schema coverage is 0%. The description adds meaning by indicating the parameter is a 'valid preview', implying a preview ID from a prior operation. This helps, but it still does not clarify how to obtain the preview or the format of the ID, so the compensation is 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 clearly states the action (Delete) and the resource (a list item), and adds a specific condition (using a valid preview). This distinguishes it from similar deletion tools for other resources (delete_list, delete_column) and from preview_delete_item, which creates a preview rather than deleting directly. However, it does not explicitly mention the workflow of first calling preview_delete_item, so the purpose is clear but not fully elaborated.

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 'using a valid preview' implies that the tool should be used after obtaining a preview, likely from the sibling tool preview_delete_item. This is contextual guidance, but the description does not explicitly state when to use this tool versus alternatives, nor does it name the exact prerequisite tool. Thus, usage is implied rather than explicitly documented.

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 mentions the requirement of a valid preview but does not disclose the permanence of deletion, potential errors, or permissions needed, leaving significant behavioral gaps.

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

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

The description is a single, front-loaded sentence that efficiently conveys the action and prerequisite, with no unnecessary words.

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

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

For a simple delete operation with one parameter, the description is adequate but does not mention the return value, error behavior, or the explicit need to call preview_delete_list first, leaving some context incomplete.

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

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

Although schema coverage is 0%, the description clarifies that the sole parameter previewId is a 'valid preview' identifier, adding meaning beyond the schema's type and minLength constraints.

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

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

The description clearly states the action 'Delete a list' with a specific resource, and 'using a valid preview' clarifies that this is the actual deletion step after a preview, distinguishing it from preview_delete_list.

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?

'Using a valid preview' implies the need to have a preview ID, but it does not explicitly instruct the agent to call preview_delete_list first, nor does it mention when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden. It indicates a destructive action ('delete') but does not disclose permanence, authorization requirements, what constitutes a 'valid preview', or consequences of invalid input. Minimal behavioral context beyond the obvious.

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

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

The description is a single concise sentence with no redundancy. It is front-loaded with the action and includes the essential prerequisite, making it efficient and clear.

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

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

The tool has low complexity (1 param, no output schema), but as a mutation tool with no annotations, the description lacks workflow guidance. It does not mention that this is the execution step after preview_delete_view, nor address side effects or return values. The dependency on a 'valid preview' is unexplained, making it incomplete for correct invocation.

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

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

Schema coverage is 0%, so the description must add meaning. It clarifies that previewId should be a valid preview identifier from a preview operation, adding context beyond the schema's type/minLength. However, it does not explain how to obtain or validate that preview.

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

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

The description clearly states the action (delete) and the target (a view), and specifies a prerequisite ('valid preview'). This distinguishes it from sibling tools like preview_delete_view (which only previews) and apply_view_update.

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 'using a valid preview' implies that a preview must have been created first, likely via preview_delete_view, but it does not explicitly state when to use this tool vs alternatives or when not to use it. No direct exclusions or alternative references are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get' which implies a read operation, but it does not state whether any metadata is returned, whether auth is needed, or any side effects. There is no contradiction, but the transparency is minimal.

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

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

The description is a single concise sentence with no unnecessary words. However, it is underspecified, lacking important context. It earns its place for purpose clarity but sacrifices necessary detail, making it too terse for proper use.

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

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

Given no annotations, no output schema, and a bare input schema, the description should provide more context. It only states the basic purpose without explaining return value, usage scenarios, or differences from sibling tools. This is insufficient for an agent to reliably select and invoke the tool.

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

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

The input schema has two required parameters (driveId, itemId) with zero description coverage. The description does not mention or explain either parameter, leaving the agent to infer their meaning from the names alone. This fails to compensate for the lack of schema descriptions.

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

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

The description 'Get Drive item metadata' clearly states a specific action (get) and resource (Drive item metadata). It is distinct from sibling tools like list_drive_items or upload_file, though it does not explicitly differentiate itself. The name suggests 'download' but the description clarifies it's metadata retrieval, which is somewhat inconsistent.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions. The description only states what it does without addressing the decision of when to use 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 full burden of behavioral disclosure. It provides no information about side effects, permissions, idempotency, or error handling. The phrase 'ensure' implies a possible mutation but gives no detail.

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 short sentence, which is concise in length but severely under-specified. It lacks necessary details, so it is not appropriately sized for the tool's purpose.

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

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

Given the tool has only one parameter but no annotations or output schema, the description is inadequate. It does not explain the operation, the meaning of 'ensure', or the expected behavior, making it nearly useless for an AI agent.

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

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

Schema description coverage is 0%, and the description does not mention the single parameter 'logonName' at all. The agent must rely solely on the parameter name, which is not explicitly defined. The description adds no semantic value beyond the schema.

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

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

The description states the tool ensures a site user exists, which indicates a goal of idempotent existence but does not specify the underlying operation (create, update, check). It is vague and does not distinguish from sibling tools like search_site_users or add_group_user.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, leaving the agent without direction for selection.

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

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

With no annotations provided, the description carries full responsibility. It adds the useful nuance of 'explicitly locked', but does not disclose whether the operation is purely read-only, what happens when no site is locked, or any error behavior.

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

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

The description is a single, concise sentence that front-loads the verb and resource. Every word contributes meaning, with no fluff or repetition.

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

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

Given the tool's simplicity, the description is nearly sufficient, but without an output schema, it should clarify the return format or behavior when no site is explicitly locked. This gap leaves room for agent confusion.

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 no parameter semantics are needed. The description correctly adds no unnecessary parameter details, earning the baseline score of 4 for parameter-less tools.

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 clear verb ('Return') and a specific resource ('explicitly locked active SharePoint site'). This distinguishes it from sibling tools like get_context and set_active_site, though the term 'explicitly locked' is somewhat ambiguous without further context.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_context or set_active_site. The relationship to set_active_site is implied but not stated, leaving the agent without explicit usage criteria.

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

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

There are no annotations, so the description carries full responsibility. It only states the operation's purpose, not any behavioral traits such as whether it is read-only, what it returns if formatting is unset, or any permission requirements. The word 'Get' implies a safe read, but no further disclosure is made.

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

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

The description is a single, clear sentence with no verbose wording. It is front-loaded and to the point. However, it is arguably too terse, omitting any parameter or usage details, but that is more an issue of other dimensions. For clarity and brevity, it scores well.

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

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

Given the lack of annotations and output schema, the description should at least mention the required parameters and the nature of the returned JSON formatting. It provides only the most basic statement of purpose, leaving the agent without enough context to know how to invoke the tool correctly or understand the output.

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

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

The schema has zero description coverage and no descriptions for listId or columnId. The description adds no information about these required parameters or how to identify the column/list. The parameters are left entirely to their names, which is inadequate for a tool that requires both parameters.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as JSON formatting for a SharePoint list column. It distinguishes from sibling tools like get_view_formatting by specifying 'column' rather than 'view', and from preview/apply update tools by using 'get' rather than 'preview/apply'. However, it doesn't explicitly say it retrieves existing formatting, though that is implied.

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

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

No guidance is provided about when to use this tool versus alternatives. It doesn't mention that this is the read-only counterpart to preview_column_formatting_update/apply_column_formatting_update, nor does it suggest using get_view_formatting for view-level formatting. The description gives no context or prerequisites.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions what is returned but does not explicitly state the operation is read-only, safe, or has no side effects. It also doesn't clarify what 'session health' means or whether any data is fresh. This is a minimal disclosure, insufficient for a tool with no annotation safety hints.

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 front-loaded with the action verb 'Return' followed by a comma-separated list of the three components. No filler or redundant wording; the description is concise and gets straight to the point.

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

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

With no output schema and no annotations, this description is the primary documentation. It lists all major return areas (active site, captured sites, session health). The absence of detail about each component's structure is a minor gap, but for a simple context getter, the description is reasonably complete for initial selection and 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?

The tool has zero parameters, which gives a baseline of 4. The description adds meaning by enumerating the returned context items, effectively telling the agent what the tool is for. Since there are no parameters to document, the description fulfills its role adequately.

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

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

The description states a clear, specific purpose: returning three named data components (active site, captured sites, session health). It distinguishes from sibling tools like get_active_site and get_health by presenting a combined context view, making it evident this is an aggregate tool.

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

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

There is no explicit guidance on when to use get_context versus calling sibling tools individually. While the combined purpose is implied, the description does not state scenarios, prerequisites, or alternatives, leaving the agent to infer when this tool is preferable.

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

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

No annotations are present, so the description carries the full burden. It only states 'Get a SharePoint site group' without disclosing return format, error behavior, permissions, or whether the group is retrieved by ID. This is minimal behavioral disclosure.

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

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

The description is a single sentence and wastes no words, but it is under-specified for a tool with no annotations or output schema. It is concise but not appropriately sized given the missing behavioral and parameter context.

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

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

For a 1-parameter getter with no output schema and no annotations, the description only covers the basic purpose. It does not mention what data is returned, how errors are handled, or how the group ID is specified. The tool is simple, but the description leaves significant gaps for an AI agent.

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

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

The schema has 0% description coverage, and the description fails to explain the groupId parameter or its meaning. No compensation is offered for the lack of schema documentation.

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

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

The description clearly states the action ('Get') and resource ('SharePoint site group'), providing a specific verb+resource pair. However, it does not explicitly distinguish this from the sibling 'list_groups' tool by mentioning single group retrieval by ID, so it misses the top score.

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

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

There is no guidance on when to use this tool versus alternatives such as list_groups or other group management tools. No context, conditions, or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions returning health but does not indicate whether this is a read-only operation, what side effects (if any) exist, what constitutes 'health,' or how the result is structured. The lack of detail leaves the agent uncertain about the tool's behavior beyond the one-line summary.

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

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

The description is a single, compact sentence that conveys the essential purpose without any wasted words. It is highly concise and front-loaded, which is appropriate for a simple health-check tool.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is minimally adequate. However, because there is no output schema, the description should explain what 'health' includes (e.g., bridge connectivity, session token validity) to give the agent a complete picture. The description is complete in scope but lacks this important detail, making it only passable.

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 correctly indicates no inputs are required, and there is no need for additional parameter explanations. The input schema confirms an empty object, which is consistent.

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

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

The description clearly states the tool's purpose: to return SharePoint MCP bridge and session health. This is a specific verb ('Return') plus a distinct resource ('health'), which differentiates it from all sibling tools that focus on lists, items, groups, pages, etc. It is immediately obvious what this tool does.

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

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

No guidance is provided on when to use this tool versus alternatives. While it is unique among siblings, the description does not state use cases such as 'check connectivity before other operations' or 'diagnose session issues.' There is no explicit context or exclusion criteria.

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

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

No annotations are present, so the description must disclose behavior. It only says 'Get a SharePoint list item and its fields,' which implies a read operation but does not mention error handling, what happens if the item is not found, or the exact response structure. Minimal behavioral detail is added beyond the tool name.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is maximally concise while conveying 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?

The tool is simple (2 required parameters, no output schema), and the description states the basic operation. However, without annotations or output schema, it does not specify response details, required list context, or edge cases, leaving some gaps for a completely self-contained definition.

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 offers no explanation for itemId or listId. The parameter names are self-explanatory from the schema, but the description adds no semantic value beyond them.

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

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

The description uses a specific verb ('Get') and names the resource ('SharePoint list item') with scope ('and its fields'). It is clear, but it does not explicitly distinguish this from sibling tools such as list_items or get_list, so it falls short of a perfect score.

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

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

No guidance is provided about when to use this tool instead of list_items (to enumerate items) or get_list (to get list metadata). The description only states the action, with no context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Get a list' and provides no information about error handling, permissions, or what is returned. For a read operation, there is no disclosure of side effects (none expected), but the lack of context leaves the agent guessing about failure modes such as 'list not found.'

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

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

The description is a single, concise sentence with no unnecessary words. It is front-loaded with the verb and resource, making it easy to parse. This is appropriate for a simple getter tool.

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

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

For a tool with one parameter, no output schema, and no annotations, the description is minimally sufficient but lacks context. It does not explain what a 'list' refers to in SharePoint, what the return value looks like, or how this tool relates to the many sibling tools (e.g., list_lists, get_item). The absence of error behavior or usage guidance makes it incomplete for an agent deciding whether to invoke it.

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

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

The schema has a single required parameter (listId) with a type and minLength but no description. Schema description coverage is 0%, so the description must compensate. It does not mention listId at all, though the tool name and the phrase 'a list' implicitly suggest the ID identifies which list. The parameter name is somewhat self-explanatory, but the description adds no explicit semantic 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?

The description uses a specific verb ('Get') and resource ('a list') and scopes it to 'the active SharePoint site.' This clearly indicates a read operation for a single list. It is not fully explicit about retrieval by ID, but the tool name and sibling presence (list_lists) imply a single-get vs. list-all distinction.

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

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

There is no guidance on when to use this tool versus alternatives. No mention that this retrieves a single list by ID, nor any reference to list_lists for enumeration or get_item for list items. The description simply states what it does without usage context.

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

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

With no annotations provided, the description must carry the burden of behavioral disclosure. The verb 'Get' conveys a non-mutating read operation, but there is no additional context about inheritance behavior, required permissions, or whether the result includes direct vs. effective role assignments. This is minimal but not misleading.

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

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

The description is a single sentence of seven words that front-loads the action and resource. Every word earns its place, and there is no wasted content.

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

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

For a simple read operation with two parameters and no output schema, the description provides the core purpose but omits details like whether the role assignments are inherited, any special permission requirements, or what the response structure looks like. It is minimally sufficient but leaves some gaps for an agent to 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%, so the description should compensate for missing parameter documentation. It references 'one list item' which hints at itemId, but listId is only implied by the word 'list'. Parameter names are self-explanatory, but the description does not explicitly explain either parameter's meaning or constraints, leaving some ambiguity.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as 'role assignments for one list item'. This distinguishes it from the sibling tool get_list_permissions, which targets list-level permissions, making the purpose unambiguous.

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

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

No guidance is provided about when to use this tool versus alternatives like get_list_permissions or the preview/apply permission update tools. The description gives no context on prerequisites, exclusions, or situations where another tool 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 provided, the description carries the full burden of behavioral disclosure. It only states 'Get role assignments,' implying a read-only operation, but does not elaborate on what role assignments are included (e.g., inherited permissions, current user vs. all users), the return format, or any side effects. This lack of detail leaves significant behavioral ambiguity.

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

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

The description is a single, concise sentence that gets straight to the point. It contains no unnecessary words or repetition, making it highly efficient.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is minimal but lacks essential context. It does not explain what the returned role assignments look like, whether inheritance is considered, or how to obtain the listId. This makes the tool less complete for an agent that needs to use it correctly without additional information.

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

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

The input schema has one parameter, listId, with no description in the schema (0% coverage). The tool description does not compensate by explaining that listId identifies the target list. While the parameter name is self-explanatory, the description adds no meaning beyond the schema's type and requirement, failing to provide necessary context.

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

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

The description clearly states the tool's function: 'Get role assignments for a list.' It uses a specific verb ('get') and resource ('role assignments for a list'), which effectively distinguishes it from sibling tools like get_list_item_permissions (which targets items) and list_role_definitions (which targets role definitions).

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention when to prefer this over get_list_item_permissions or list_role_definitions, nor does it provide any exclusions or prerequisites. Usage is only implied by the tool's name and brief description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but the description does not state return format, error behavior, permissions required, or any side effects. This is a minimal disclosure for a tool with no structured safety hints.

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?

At four words, the description is terse but not usefully concise. It omits essential context, making it under-specified rather than efficiently structured. A good concise description would still communicate key details like 'by pageId'.

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 getter, the description is minimally complete, but the lack of output schema and annotations increases the burden on the description. It does not clarify what 'modern page' means, what data is returned, or any limitations, leaving significant 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?

The schema has one required parameter 'pageId' with 0% description coverage. The description does not explain what pageId is, its format, or how it relates to the page being fetched. The parameter name is somewhat self-explanatory, but the description adds no value beyond the schema.

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

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

The description uses a clear verb ('Get') and resource ('a modern page'), indicating it retrieves a single page. However, it lacks explicit mention of retrieval by pageId and doesn't differentiate from list_pages or other page-related tools beyond implying singular vs. plural.

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

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

No guidance is provided on when to use this tool versus alternatives like list_pages or get_context. There is no mention of prerequisites, intended use cases, or exclusions, leaving the agent without context for tool selection.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read operation, but the description does not disclose any additional behavioral details such as permissions required, error handling, or the structure of the returned JSON. It adds little beyond what the tool name already suggests.

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

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

The description is a single sentence of ten words, front-loaded with the verb and resource. Every word is informative, with no fluff or repetition.

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

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

This is a simple read tool with two parameters and no output schema, but the description is too sparse. It does not explain what 'JSON formatting' means, what the return value contains, or how this tool relates to formatting updates. The lack of annotations and output schema makes this description insufficient for a fully autonomous 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?

The schema has 0% description coverage, and the description does not explain listId or viewId. While the parameter names are intuitive in a SharePoint context, the description fails to compensate for the missing schema documentation, leaving the agent to guess the expected format or relationship between them.

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 'Get JSON formatting for a SharePoint list view' clearly states the action (get) and the resource (JSON formatting for a view). It distinguishes itself from sibling tools like get_column_formatting and preview_view_formatting_update, which operate on columns or perform updates rather than reads.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it is for reading current formatting, nor does it point to preview_view_formatting_update or apply_view_formatting_update for modifications. The agent must infer usage purely from the name.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It simply states the listing action without mentioning whether the operation is read-only, whether it reflects live browser state, or any side effects. Given that this is a list operation, the lack of a read-only hint or other context leaves the agent uncertain about the tool's behavior.

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

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

The description is a single, clear sentence with no redundant words. It is front-loaded with the action and resource, making it easy for an agent to quickly grasp the tool's purpose.

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

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

Given the tool's simplicity (no params, no output schema), the description provides adequate context for the agent to understand what the tool does. It could mention the return format or any prerequisites, but for a basic listing tool, the current level of detail is sufficient. No critical missing information for this simple use case.

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

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

The input schema has zero parameters, so there are no parameter semantics to explain. According to the baseline rule for 0 parameters, a score of 4 is appropriate since the description does not need to add parameter-specific information.

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 'List' and states the exact resource: SharePoint Online sites captured from open browser tabs. This clearly distinguishes it from sibling tools like list_groups or list_pages, which focus on different resources.

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 'captured from open browser tabs' implies the tool is used when the user wants to see sites that have been captured from their browser. However, it does not explicitly mention when to use this over alternatives like get_active_site or set_active_site_from_tab, nor does it provide exclusions. The usage context is implied rather than clearly 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 burden of disclosing behavior. The verb 'List' implies a read-only operation with no side effects, which is minimal but acceptable. However, it does not explicitly state read-only nature, permissions, or return behavior, so it only partially reveals behavioral traits.

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

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

The description is a single, concise sentence with no filler words. It directly states the tool's purpose and is appropriately sized for the simple operation.

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

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

The tool has no output schema or annotations, and the description is sparse. It does not specify what information the response contains (e.g., column names, metadata), nor does it mention how listId relates to other tools like list_lists. The description is minimally adequate for a trivial read operation but lacks important contextual 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 coverage is 0%, so the description must compensate for the undocumented parameter. It mentions 'a SharePoint list' but does not explicitly explain that the 'listId' parameter is the list identifier, how to obtain it, or its format. The parameter name is self-explanatory, but the description adds little beyond the schema.

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

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

The description uses a specific verb ('List') and a clear resource ('columns in a SharePoint list'), which unambiguously identifies the tool's function. It differentiates from sibling tools like list_lists (lists vs. columns) and list_items (items vs. columns).

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. It only states the basic function, so the usage context is entirely implied.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. The phrase 'List drive items' implies a read-only operation, but does not mention pagination, sorting, permissions, or return format. It gives minimal behavioral context beyond the name.

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

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

While the description is extremely short (three words), this is under-specification rather than conciseness. It omits essential information about parameters, behavior, and return values, so it does not earn its place as a useful tool description.

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?

This is a simple list operation with only two parameters, no output schema, and no annotations. However, even simple tools need more context about what is listed and how filtering works. The description is too sparse to fully support an agent's invocation decisions.

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 does not explain the purpose of 'itemId' or 'driveId' (both of which are strings, with 'driveId' required). The 'itemId' property references '#/properties/driveId', which is confusing. The description adds no semantic meaning beyond the raw schema.

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

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

The description uses a specific verb ('List') and resource ('drive items'), which clearly indicates a read operation. However, it does not specify what constitutes a drive item (e.g., files, folders) or how this differs from sibling tools like 'list_drives' or 'list_items', leaving some ambiguity.

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

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

There is no guidance on when to use this tool versus alternatives like 'list_drives' or 'list_recycle_bin'. The description simply states the action without providing context, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden. It indicates a read-only 'list' operation but provides no additional behavioral detail such as permissions, return format, or whether it lists all drives or only accessible ones. Lacks the context needed for full transparency.

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

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

The description is a single concise sentence, 'List site drives,' which is front-loaded and every word earns its place. No fluff.

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

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

For a simple list operation with no parameters and no output schema, this description is mostly complete. It clearly states the resource type, though it could mention the scope (e.g., all drives vs. accessible drives) to be fully contextual.

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 adds no parameter info, but none is needed.

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

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

The description 'List site drives' uses a specific verb 'list' and a clear resource 'site drives'. It distinguishes from sibling tools like list_drive_items, which lists items within a drive, and other drive-related 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 description implies usage: when you need to enumerate available drives. It does not explicitly mention alternatives or exclusions, but the intended context is reasonably clear from the action and resource.

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

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

With no annotations, the description carries the full burden. It only says 'List SharePoint site groups' and does not disclose return format, scope, pagination, permissions, or confirm the read-only nature beyond the verb 'List'.

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

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

The description is a single sentence with no filler or redundant wording. Every word contributes to the meaning, making it maximally concise.

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

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

For a zero-parameter list tool, the description is minimally sufficient, but it omits useful context present in sibling tools, such as operating on the active site or the structure of returned group objects. With no output schema, the description could have provided a bit more clarity.

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

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

The tool has zero parameters, and the schema is empty, so the description need not add parameter meaning. The baseline for no parameters is 4, and there is nothing to deduct.

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

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

The description uses the specific verb 'List' and identifies the resource as 'SharePoint site groups', clearly distinguishing it from sibling tools like get_group, create_group, and list_group_users. It precisely states what the tool does.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that it lists groups for the active site or how it relates to get_group or list_group_users, leaving the agent to infer usage.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'List users in a site group,' which implies a read operation, but it does not disclose return format, pagination, permission requirements, or whether inherited users are 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?

The description is a single six-word sentence that directly states the action with no redundancy. It is front-loaded and every word earns its place.

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

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

Given the lack of annotations, output schema, and the presence of many sibling tools, this minimal description leaves significant gaps. It does not explain what user data is returned, whether the operation is read-only, or any filtering behavior, making it incomplete 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?

The schema has 0% description coverage for the sole parameter groupId, and the description does not mention it at all. While the parameter name is somewhat self-explanatory, the description adds no semantic value beyond the raw schema.

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

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

The description 'List users in a site group' uses a clear verb and resource, and it is distinct from siblings like list_groups and get_group. However, it lacks explicit scope (e.g., whether it lists all users or only direct members), preventing a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any situational context, prerequisites, or exclusions, leaving the agent without decision support.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning whether the operation is read-only, how many items are returned, or what the response includes. It adds no context beyond what the name implies.

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

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

The description is a single, concise sentence with no redundant words. It is front-loaded and to the point, but it is somewhat under-specified, which prevents a perfect score.

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

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

For a simple read-only list operation with one parameter, this is minimally viable: it states what the tool does. However, it lacks information about output structure, any limitations, and does not leverage context from sibling tools to clarify its distinctive role, so it is not fully complete.

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

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

With 0% schema description coverage, the description should compensate by explaining the listId parameter. However, it only says 'in a SharePoint list,' which indirectly hints at the parameter's purpose but does not explicitly define it or clarify its required 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 'List items and fields in a SharePoint list' clearly identifies the verb and resource, and the scope 'in a SharePoint list' adds context. It is distinct from siblings like list_lists and get_item, but it does not explicitly differentiate itself from list_columns, which also deals with fields, leaving slight ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_item or list_columns. There is no mention of prerequisites, exclusions, or typical use cases, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, the description must carry the behavioral transparency burden. It adds the useful scoping constraint of 'active SharePoint site' but does not disclose return format, pagination, or whether hidden lists are 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?

One short sentence with no redundancy, front-loaded and efficiently communicates the core function.

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

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

For a simple listing tool with no parameters, the description is largely adequate but lacks details about the output structure or any filtering behavior, which would be helpful given the absence of an output schema.

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

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

There are no parameters, so the baseline of 4 applies. The description correctly avoids inventing parameters.

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

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

The description clearly specifies the action (list), the resource (lists), and the scope (active SharePoint site), making it distinct from sibling tools like list_pages or list_groups.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_list for a specific list or create_list for adding lists. It simply states the function without exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden. It discloses that both successes and failures are returned and that token values and file content are redacted, which are important behavioral traits. It doesn't mention ordering or pagination, but for a simple listing tool, the disclosure is adequate.

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

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

The description is two concise sentences with no filler. It front-loads the core action and adds necessary detail about redaction, every sentence earns its place.

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

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

For a simple listing tool with no output schema, the description covers the essential scope (local MCP calls), content (success/failure), and privacy aspects (redaction). It doesn't describe return format or ordering, but these are minor gaps given the low complexity.

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

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

The schema defines a single parameter 'limit' with clear type, min, max, and default. The description doesn't mention this parameter, but the schema is self-explanatory. Since schema description coverage is 0%, the description adds no additional meaning, though the parameter's purpose is self-evident from its name and constraints.

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

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

The description clearly states the verb and resource: 'List local MCP tool calls', and adds specificity by noting it includes both successes and failures. This distinguishes it from sibling tools, which are mostly SharePoint-related and focus on entities like pages or lists.

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 tool is for auditing or reviewing local MCP tool call history, providing clear context. It doesn't explicitly list exclusion criteria or alternatives, but its unique purpose among siblings makes the usage context obvious.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states 'List modern pages' without detailing return format, pagination, permissions, or what 'modern' means. It reveals almost nothing about the tool's actual behavior.

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

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

The description is a single concise sentence with no redundant words, making it efficient. However, its extreme brevity means it lacks any structural detail or helpful elaboration, so it earns a high but not perfect score.

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

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

There is no output schema, no annotations, and no parameters; the description is the sole source of context. It does not explain what the return value looks like, the scope of the listing (e.g., active site vs. site collection), or any limitations, making it insufficient for a simple tool.

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

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

The input schema is empty (0 parameters), so the baseline is 4. The description does not need to add parameter semantics because there are no parameters to describe, and it correctly stays silent on this dimension.

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 'List modern pages' clearly states the action (list) and the resource (pages), and there is no sibling tool for listing pages, so it differentiates itself effectively. However, the term 'modern' is undefined, leaving the exact scope ambiguous, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions, despite the presence of numerous sibling list_* tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action 'List' but does not mention read-only behavior, return format, pagination, or what constitutes a recycle-bin item. This is minimal and lacks explicit context about side effects or output.

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, short sentence that is front-loaded with the verb and resource. There is zero wasted text; every word contributes 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?

The tool is simple with no parameters, but the description offers no information about the return value, whether it is a read-only operation, or any variations in behavior. Since there is no output schema to fill the gap, the description alone is somewhat under-specified, though the basic purpose is clear.

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

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

There are no parameters (0 params), and the schema is an empty object, so schema coverage is effectively 100%. Per rubric, a 0-parameter tool earns a baseline of 4. The description adds domain context by specifying 'site recycle-bin items' but does not need to elaborate on parameter meanings since none exist.

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

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

The description clearly states the verb 'List' and the specific resource 'site recycle-bin items'. It is distinct from sibling list tools by explicitly identifying the recycle bin resource, so there is no ambiguity about what this tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives. It merely states what it does without any context, prerequisites, or exclusions, leaving the agent to infer usage solely from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'list', implying a read-only operation, but provides no details about pagination, return format, permissions, or side effects. This is minimal and does not add context beyond the name.

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

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

The description is extremely concise—a single sentence with no wasted words. However, it is essentially a restatement of the tool name, offering little additional value. It is not overly verbose, but also not rich in content, so it falls short of a 5.

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 list tool with no parameters, the description is minimally sufficient. It states the action and resource, but since there is no output schema, it could have clarified what the returned role definitions look like or the scope (e.g., site-level). The description is adequate but lacks any contextual depth.

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

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

The tool has zero parameters, and the schema is trivially 100% covered. The baseline for no parameters is 4, and the description does not need to add parameter details. No information is missing here.

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

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

The description uses the specific verb 'list' and the resource 'SharePoint role definitions', making the tool's purpose immediately clear. It distinguishes itself from sibling tools by targeting role definitions, a distinct resource not covered by any other 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 guidance on when to use this tool versus alternatives. No exclusions, prerequisites, or recommended contexts are provided, leaving the agent to infer usage solely from the description.

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

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

No annotations are provided, so the description carries the full burden. It only states the basic action without disclosing any behavioral traits such as pagination, ordering, return format, permissions, or whether it includes hidden views. This is a 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?

The description is a single sentence with no wasted words, making it appropriately concise for a simple operation. However, it is so minimal that it lacks useful structural details, though this does not significantly hurt its readability.

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

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

With no output schema and no annotations, the description should explain what the tool returns and any relevant context. It does not describe the return value or the listId parameter format, leaving gaps for an agent to fully understand the tool's 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?

The schema has 0% description coverage for the listId parameter, and the description does not explicitly define what listId is. It only hints indirectly via 'in a SharePoint list', leaving the parameter semantics under-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?

The description uses a specific verb 'List' with resource 'views' scoped to 'a SharePoint list', clearly distinguishing it from sibling tools like list_lists, list_items, and list_columns. The purpose is immediately obvious and unambiguous.

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

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

Usage is implied by the description and name—the tool lists views for a given list—but no explicit when-to-use guidance or alternatives are provided. It does not mention exclusions or prerequisites, so it stops at 'implied usage'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to mention any side effects (e.g., the item is removed from its original location), permission requirements, reversibility, or return values, leaving the agent without critical operational information.

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

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

The description is extremely terse, consisting of a single simple sentence. While it is concise, it is under-specified and does not provide sufficient information for an agent to correctly invoke the tool; it is more of a label than a useful description.

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

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

The tool has a moderately simple operation with three parameters, no annotations, no output schema, and no parameter descriptions. The description is essentially just a label and fails to provide any context about the operation's purpose, parameter meanings, or expected behavior, making it far from complete for an agent to use effectively.

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

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

The input schema defines three required parameters (driveId, itemId, parentId) but provides zero description coverage. The description 'Move a drive item' does not explain any of these parameters, leaving their semantics entirely ambiguous and failing to compensate for the schema's lack of descriptions.

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

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

The description states the specific action 'move' and resource 'drive item', clearly indicating the tool's primary function. It distinguishes from sibling tools like copy_drive_item and delete_drive_item through the unique verb, but lacks additional context about the move's target or behavior.

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

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

The description provides no information about when to use this tool, what prerequisites exist, or how it compares to alternatives such as copy_drive_item or delete_drive_item. There is no guidance on context, exclusions, or alternative use cases.

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

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

With no annotations provided, the description must disclose behavioral traits on its own. 'Preview' hints at a non-destructive operation, but the description doesn't confirm whether it makes changes, what it returns, or how it handles invalid input. This is a significant gap for a tool that appears to be a mutation-adjacent preview.

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 short sentence with no filler words, making it highly concise. However, it lacks any structured breakdown of purpose or parameters, so while efficient, it is not as informative as it could be.

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

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

Given that this is a preview operation with three required parameters, no annotations, and no output schema, the description is far too minimal. It doesn't explain what a 'preview' returns, how it differs from the apply operation, or any behavioral context, making it insufficient for an agent to safely invoke it.

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

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

The input schema has three required parameters with 0% description coverage, and the description adds no meaningful information about them. It vaguely hints at 'formatting' but leaves listId and columnId undefined, failing to compensate for the schema's lack of parameter descriptions.

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

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

The description specifies a clear action ('Preview updating') on a specific resource ('column JSON formatting'), which distinguishes it from sibling tools like apply_column_formatting_update and get_column_formatting. However, it doesn't elaborate on what 'column JSON formatting' entails exactly, so it's clear but not fully explicit.

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 'Preview' implies this tool is for inspecting an update before applying it, and sibling names suggest an apply counterpart. However, the description provides no explicit guidance on when to use this versus alternatives, nor does it mention any exclusions or prerequisites.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, but it only states the action without revealing side effects, return format, or validation behavior. It is implied that 'preview' is non-destructive, but this is not explicitly stated. The description does not disclose what happens on success or failure.

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 short sentence, making it very concise and front-loaded. However, it may be too brief, sacrificing important context for brevity. It does not introduce extraneous 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?

Given that the tool has a nested 'updates' object and no output schema or annotations, the description is insufficient for an agent to understand the expected input and preview behavior. The lack of detail about the update structure and return value leaves significant gaps. The description is complete only as a high-level summary, not as a functional specification.

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

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

The schema provides zero description coverage, and the description does not explain the meaning or structure of the parameters. The 'updates' object is particularly opaque—it is not described what keys or values it expects. The description adds no semantic value beyond the parameter names themselves.

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

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

The description clearly identifies the action as 'preview updating' and the resource as 'a SharePoint list column.' This distinguishes it from sibling tools like 'apply_column_update' that would perform the actual update. The verb is specific enough to understand the tool's function.

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

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

The description provides no guidance on when to use this tool versus the alternative 'apply_column_update' or other preview tools. There is no mention of prerequisites such as the column existing, or that the preview is a dry run before applying. No usage context 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 must disclose behavioral traits. It only says 'Preview deleting' without explaining what a preview entails (e.g., dry-run result, impact assessment, permission requirements). This is nearly a restatement of the tool name and fails to convey meaningful behavioral context.

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

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

The description is a single concise sentence with no wasted words, but it is under-specified. It is not verbose, but it misses the opportunity to provide useful details. Conciseness alone earns a good score, but the lack of content prevents a perfect score.

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

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

Given the tool has only two parameters, no output schema, and no annotations, the description is far from complete. It does not explain what 'preview' means, what the parameters refer to beyond their names, or what output to expect. The tool is part of a large family of preview/apply/delete siblings, and the description gives no contextual guidance for correct selection or usage.

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 description provides no additional meaning for the parameters columnId and listId, and the input schema has 0% description coverage. While the parameter names are somewhat self-explanatory, the description does not compensate for the lack of schema documentation, and the schema itself contains a suspicious $ref for listId that goes unclarified.

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 'Preview deleting a SharePoint list column' clearly states the verb (preview deleting), the resource (SharePoint list column), and differentiates from the sibling delete_column tool by indicating this is a preview action. It is specific and unambiguous.

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

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

The word 'preview' implies this should be used to check the outcome of a deletion before actually executing it, but the description does not explicitly state when to use it versus alternatives like delete_column or preview_delete_item. Usage is implied rather than explained.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Preview deleting' implies a non-destructive action but does not state that no deletion occurs, what the preview returns, or any side effects. This is a significant gap for a tool that could be confused with an actual 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?

The description is a single, front-loaded sentence with no fluff, which is concise. However, it is under-specified and lacks any structure (e.g., examples, notes), making it minimally adequate but not well-rounded.

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

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

Given the tool has 3 required parameters, no annotations, and no output schema, a one-sentence description is wholly inadequate. It does not explain what the preview shows, how to interpret results, or any operational context. The description is far too shallow for effective tool selection and 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?

The input schema has 0% description coverage, and the description adds no parameter information. The three required parameters (driveId, itemId, name) are unexplained, and 'name' is especially ambiguous given the schema's unusual $ref definitions. The description does nothing to compensate for the lack of schema documentation.

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

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

The description states 'Preview deleting a drive item' with a specific verb and resource, clearly distinguishing this from the sibling tool 'delete_drive_item' and other preview actions. It directly conveys what the tool does.

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

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

Usage is only implied by the 'preview' prefix and the existence of 'delete_drive_item' as a sibling, suggesting this is a safe dry-run before actual deletion. However, there is no explicit guidance on when to use this tool versus alternatives or when not to use 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 must disclose the tool's behavioral traits, but it only states 'Preview deleting a list item.' It does not explicitly confirm that the operation is non-destructive, what the preview returns, or whether any side effects occur. The word 'preview' implies non-destructiveness, but this is not explicitly stated, leaving significant room for misinterpretation.

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

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

The description is a single sentence, 'Preview deleting a list item,' with no unnecessary words. It is concise and front-loaded, making it easy to parse. The brevity is appropriate for a tool with a simple action and two parameters, though it sacrifices explanatory depth.

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

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

Given the tool's low complexity (2 params, no output schema), the description is too sparse to be complete. It lacks behavioral context, usage guidance, and parameter semantics. The agent must rely on the sibling tool names and the word 'preview' to infer that this is a safe, non-committal delete operation, which is insufficient for confident 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?

The schema has two required parameters (itemId, listId) with 0% description coverage, and the tool description provides no additional meaning for these parameters. The parameter names are somewhat self-explanatory, but the description fails to clarify their roles or provide any context beyond the schema. This does not compensate for the lack of schema documentation.

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

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

The description 'Preview deleting a list item' clearly identifies the action (preview delete) and the resource (list item), distinguishing it from sibling tools like delete_item (actual deletion) and preview_item_update (update preview). However, it does not elaborate on what 'preview' entails, leaving some ambiguity about the operation's exact purpose.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention that it should be used instead of delete_item to check effects before committing, nor does it reference any other related tools. An agent is left to infer usage from the sibling list and 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?

With no annotations provided, the description carries the full burden of explaining behavior. It fails to state whether the tool modifies the list, returns a dry-run result, or is safe. The word 'preview' implies non-destructive but does not explicitly disclose this critical behavioral trait.

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

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

The description is extremely brief (one sentence), but brevity here is under-specification rather than appropriate conciseness. It omits essential information about the tool's purpose, behavior, and parameters.

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

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

Given the lack of annotations and output schema, the description is woefully incomplete. It does not explain what a 'preview' returns, whether state changes, or how to interpret results, making it impossible for an agent to use the tool correctly without external knowledge.

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

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

The input schema has one required parameter 'listId' with no description, and schema description coverage is 0%. The description 'Preview deleting a list' does not explain what 'listId' refers to or how to obtain it, leaving the agent without any additional meaning beyond the parameter 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 'Preview deleting a list.' simply restates the tool name 'preview_delete_list' without adding clarity about what 'preview' means or what the tool actually does. It does not explain the difference from 'delete_list' or what a preview entails.

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

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

No guidance is provided about when to use this tool versus alternatives like 'delete_list' or 'preview_list_update'. There is no mention of calling this before deletion or any conditions under which this tool is 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 provided, the description carries the full burden of behavioral disclosure. It says 'Preview deleting' but does not explain whether this is non-destructive, what it returns, or what side effects it may have. The term 'preview' is ambiguous without further context.

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

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

The description is a single concise sentence with no filler. While it is under-specified in content, it is appropriately sized and front-loaded for a simple tool description.

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

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

Given that this is a preview operation with no output schema and minimal annotations, the description is incomplete. It does not explain what 'preview' entails, what the agent should expect as output, or how it relates to delete_view. Critical context is missing.

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

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

The schema has zero description coverage for its two parameters (listId, viewId), and the description does not mention them at all. The tool provides no additional meaning beyond the raw schema, failing to compensate for the missing parameter documentation.

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

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

The description clearly identifies the resource (SharePoint list view) and the action (preview deleting), making the basic purpose understandable. However, it does not explicitly distinguish this from the sibling delete_view tool, which is a minor omission.

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

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

There is no guidance on when to use this tool versus the actual delete_view or other preview tools. The 'preview' prefix implies a dry-run, but the description does not state this or any recommended 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 must disclose behavior, but it simply restates the tool's purpose. It does not indicate that previewing is non-destructive, what side effects exist, or what the output represents, leaving the agent without crucial behavioral information.

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

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

The description is short and contains no filler, but it is so minimal that it borders on under-specification. It is concise but does not use the space to provide valuable context, making it less useful than a slightly longer description.

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

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

Given the tool's complexity (two parameters, one being an open object) and the absence of annotations and output schema, this description is grossly insufficient. It leaves critical questions unanswered about what constitutes a valid update, how the preview is returned, and whether it validates constraints.

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

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

The schema has zero coverage for groupId and updates, and the description does not explain these parameters. updates is an arbitrary object with no structure described, so the agent has no idea what fields or format to use. The description fails to compensate for the missing schema documentation.

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

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

The description clearly identifies the tool as previewing a site group update, using a specific verb and resource. It distinguishes from siblings like apply_group_update and preview_list_update by naming 'group', but lacks detail on what the preview entails.

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

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

There is no guidance on when to use this preview versus apply_group_update, nor any context about prerequisites or workflow. The description provides no cues about appropriate vs. inappropriate usage scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Preview a list item field update' without mentioning what the preview returns, whether it validates data, if it has side effects, or any permission requirements. The term 'preview' hints at non-destructive behavior, but this is not explicitly stated.

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

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

The description is a single, focused sentence with no fluff or redundancy. It is appropriately concise for a simple tool, though it could benefit from more detail. The structure is clear and front-loaded, but the extreme brevity borders on 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?

Given the tool has 3 required parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain what the preview shows, how the parameters interact, or what the response looks like. A user would have no idea what to expect from this tool beyond its name.

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

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

Schema description coverage is 0%, meaning the description must compensate for the lack of parameter details. The description only mentions 'field update', which maps to the 'fields' parameter, but provides no information about itemId, listId, or the structure of the fields object. Parameter names are somewhat self-explanatory, but the description adds no real semantic 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?

The description clearly states the tool's purpose: 'Preview a list item field update.' It uses a specific verb ('preview') and a specific resource ('list item field update'), distinguishing it from siblings like apply_item_update and preview_list_update. The term 'preview' unambiguously indicates a dry-run operation.

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

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

The word 'preview' implies this tool should be used before applying an update, and the sibling 'apply_item_update' suggests a related workflow. However, there is no explicit guidance on when to use this tool versus alternatives or any prerequisites. The usage context is only implied, not 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?

The word 'Preview' conveys that the tool does not apply changes, which is a key behavioral trait. However, the description does not disclose what the preview returns, whether it validates permissions, or any side effects. With no annotations provided, the description only partially covers transparency.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. It contains no filler or redundant information, making it easy to parse.

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

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

Given the tool's complexity (permission changes with nested structure), the description is too minimal. It omits the relationship to the corresponding apply tool, what the preview output looks like, and any context about 'high-risk' changes. The lack of an output schema and annotations increases the need for a richer description, which is absent.

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

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

The description makes no reference to the three parameters (listId, itemId, changes). Schema description coverage is 0%, and the description does not compensate by explaining the purpose or structure of the changes array, actions, or principals. The tool name and schema properties hint at meaning, but the description adds no semantic 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?

The description clearly identifies the action ('Preview') and the resource ('permission changes for one list item'). It distinguishes this from sibling tools like apply_list_item_permission_update (which applies rather than previews) and preview_list_permission_update (which targets list-level rather than item-level permissions).

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention that this is a dry-run before applying changes nor that apply_list_item_permission_update should follow, nor does it distinguish from list-level previews. Usage is only implied by the word 'Preview'.

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

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

With no annotations provided, the description carries the full burden. 'Preview' indicates a non-mutating dry-run, but the description does not disclose what the preview returns, whether it validates changes, or any safety implications. This is a significant gap for a preview tool.

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

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

The description is a single sentence with no filler, making it efficient and front-loaded. However, the brevity sacrifices necessary detail, which is penalized under completeness rather than con conciseness.

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

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

The tool has moderate complexity with nested objects in the changes parameter, no output schema, and no annotations. The description is too sparse to inform an agent how to correctly invoke the tool or interpret results.

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

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

The schema has 0% description coverage, and the description only names 'permission changes' generally, offering minimal insight into the 'changes' structure (action, principalId, roleDefId) or the listId parameter. It fails to compensate for the schema's lack of descriptions.

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

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

The description uses the specific verb 'preview' and names the resource 'list permission changes', clearly stating what the tool does. It is distinguishable from sibling preview tools by focusing on permissions, though it doesn't explicitly reference the apply counterpart.

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 using this tool to preview permission changes before applying them, but does not explicitly state when to use it vs alternatives or provide exclusion criteria. The 'high-risk' adjective is suggestive but not actionable 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 full responsibility for disclosing behavioral traits. It does not mention return values, side effects, safety, or whether the preview is read-only. The user is left without any indication of what the tool actually does beyond the name.

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

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

The description is a single sentence that is under-specified rather than appropriately concise. It simply restates the tool name with articles, adding no value, so it fails to earn its place.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description is severely incomplete. It does not explain what the preview does, how to interpret the result, or any constraints, making it inadequate for a tool with nested object parameters and many 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 provides no parameter explanations. Both required parameters (listId and updates) are undefined, and the structure of the 'updates' object is completely unspecified. The description adds no meaning beyond the raw schema.

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

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

The description 'Preview a list update' is nearly a tautology, restating the tool name without adding any specific context. It names a verb and resource but doesn't clarify what constitutes a 'list update' or distinguish it from sibling tools like apply_list_update or preview_delete_list.