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

Annotations already establish that the tool mutates state (readOnlyHint=false) and is not idempotent. The description adds no extra behavioral context such as duplicate handling, whether existing memberships are replaced, or authorization requirements.

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

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

The description is a single concise sentence with no wasted words, and the core action is front-loaded. It is efficient, though it is so terse that it mostly restates the tool name and could be slightly more informative without harming 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?

For a mutation tool with no output schema, the description is sparse: it doesn't mention duplicate behavior, idempotency consequences, error conditions, or how member types map to parameters. The schema partially compensates by listing the member-type arrays, but the overall tool definition leaves important operational context implicit.

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

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

Schema coverage is 100%, so the baseline is 3; the description itself contributes no parameter details. The schema's Russian descriptions for the member-ID arrays are meaningful, but accessGroupId is only described as 'integer (required)', which is a tautology rather than a semantic explanation.

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 ('Add members') on a specific resource ('an access group'), which clearly distinguishes it from sibling tools like AccessGroupsCreate, AccessGroupsDelete, and AccessGroupsGetDetails. However, it does not enumerate member types such as teachers, group classes, or individual classes, leaving some purpose detail to the schema.

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

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

No guidance is provided on when to use this tool versus alternatives such as AccessGroupsRemoveMembers or AccessGroupsCreate. The description gives no selection criteria, no recommended conditions, and no 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?

The description accurately communicates the core effect of creating an access group, which aligns with readOnlyHint=false and idempotentHint=false. However, it adds no behavioral details beyond that, such as name uniqueness, permission requirements, or side effects.

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

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

A single sentence that directly states the tool's purpose with no unnecessary words. This is appropriately concise for a simple one-parameter create 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 is simple: one required parameter, no nested objects, and no output schema. The description and schema together provide enough information to invoke it correctly, though it does not mention return values or relationship to member-management 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 100%, so the baseline of 3 applies. The description does not elaborate on the 'name' parameter beyond what the schema already provides, but for a single obvious required parameter, no extra explanation is critical.

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

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

Clearly states the verb 'Create' with the resource 'access group', making the tool's purpose unambiguous. It is distinct from siblings like AccessGroupsDelete, AccessGroupsGetDetails, and AccessGroupsAddMembers.

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 about when to use this tool versus alternatives. It does not mention that member assignment is handled by AccessGroupsAddMembers/RemoveMembers or any prerequisites or follow-up steps.

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

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

Annotations already declare destructiveHint=true; the description goes further by specifying that the access group is removed and by surfacing the client-side approval requirement. This adds behavioral context beyond the annotations without contradicting them.

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

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

Two compact sentences with the core action front-loaded and the warning separated. Every sentence earns its place with no 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 single-parameter, no-output-schema mutation tool, the description covers the essential facts: what is deleted, the destructive nature, and an approval prerequisite. It is slightly vague about post-deletion effects, but adequate for invoking the tool correctly.

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

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

Schema coverage is 100% for the only parameter (accessGroupId), though its description is minimal ('integer (required)'). The tool description adds no extra parameter meaning beyond what the schema already provides, so baseline 3 applies.

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

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

States a specific verb ('Delete') and resource ('access group'), clearly distinguishing this from sibling operations like AccessGroupsCreate, AccessGroupsGetDetails, and AccessGroupsRemoveMembers by targeting the whole group rather than members.

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

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

No explicit guidance on when to use this tool versus alternatives such as AccessGroupsRemoveMembers or AccessGroupsCreate. Usage is only implied by the name and description, and the client-side approval note is a prerequisite, not a selection criterion.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds no behavioral context beyond that—no mention of response shape, error behavior, pagination, or permission requirements. It neither contradicts the annotations nor meaningfully extends them.

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

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

The description is one short, front-loaded sentence with no filler. Every word contributes to understanding the tool's purpose and scope.

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

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

For a one-parameter get-by-id tool with read-only annotations, the description is largely sufficient. The main gap is the lack of an output schema and no explicit note about the shape of the returned 'details', but the tool name and 'Get details' phrasing make the expected outcome reasonably clear.

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

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

Schema description coverage is 100%, so the baseline is 3. The single parameter accessGroupId is self-explanatory, and the description reinforces that it identifies the access group, but it does not add details about where the id comes from or any constraints beyond the schema's int32 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 uses a specific verb ('Get') and resource ('details of a single access group by id'), clearly distinguishing it from sibling tools like AccessGroupsGetList or AccessGroupsGetTeachers. The scope is precisely defined as a single entity identified by accessGroupId.

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: use this when you need details for one access group by its id. However, it does not explicitly say when not to use it or name alternatives such as AccessGroupsGetList for bulk retrieval, leaving an agent to infer the boundary from sibling names.

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

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

The readOnlyHint and destructiveHint annotations already communicate the safe read-only nature of the operation. The description adds that the result is paginated, which is a useful behavioral detail, but it does not disclose pagination defaults, ordering, or response contents. This is acceptable but not exceptional given the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's function and scope.

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 paginated read-only list operation, the description plus the schema is mostly sufficient. The accessGroupId parameter is required and clear, and pagination is mentioned. A stronger description might note default pagination values or the shape of returned group classes, but the absence is not a major blocker.

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

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

All three parameters have schema descriptions, but those descriptions are mostly tautological ('integer (optional)', 'integer (required)'). The tool description clarifies that Skip and Take relate to pagination, which adds some meaning, but it does not specify their exact semantics or default behavior.

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

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

The description uses a specific verb ('List') and names a clear resource ('group classes linked to an access group'), which distinguishes it from sibling tools like AccessGroupsGetIndividualClasses. The mention of 'paginated' adds a useful scope qualifier that further differentiates the 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 description implies the use case: when you need group classes associated with a specific access group. However, it does not explicitly mention when not to use it or point to alternatives such as AccessGroupsGetIndividualClasses or GroupClassesGetList, so usage guidance is only implied rather than 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?

Annotations already declare this as read-only and non-destructive. The description adds the pagination behavior, which is useful and not represented in the annotations, but it does not disclose details such as default page size, ordering, or error/empty-result behavior. This is adequate but not richly transparent.

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

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

One short sentence states the action, resource, linking relationship, and pagination without any filler. The key scope ('individual classes') is front-loaded and the 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 straightforward read-only list operation with clear annotations and only one required parameter, the description is nearly complete. It would benefit from a brief note on Skip/Take semantics or default pagination, but nothing critical is missing for an agent to invoke the tool correctly.

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

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

The input schema has 100% description coverage, but those descriptions are basically tautological ('integer (optional)' / 'integer (required)'). The description's 'paginated' hint connects Skip and Take to pagination, adding some meaning, but it still does not explain how Skip and Take interact or what defaults apply. Baseline 3 is appropriate because the schema carries the parameter existence burden.

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

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

The description uses a specific verb ('List') with a clear resource ('individual classes linked to an access group') and adds the 'paginated' qualifier. It clearly distinguishes itself from sibling tools like AccessGroupsGetGroupClasses, which lists group classes instead of individual classes.

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 makes the use case clear by stating that this returns individual classes linked to an access group, implicitly separating it from sibling tools for group classes, teachers, and access group management. It does not explicitly name alternatives or state when not to use the tool, but the context is evident from the resource phrase.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear without the description. The description adds the filter-by-teacher/group-class/individual-class scope, but does not disclose behavior such as whether multiple filters combine, whether results are paginated, or what ordering is applied. No contradiction with annotations exists.

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

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

The description is a single efficient sentence with the main action front-loaded and the optional filter conditions stated compactly. There is no wasted wording or redundant repetition of the 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?

For a simple, read-only list operation with three optional parameters and no output schema, the description provides enough context to select and invoke the tool. The main gap is the lack of explicit differentiation from closely related AccessGroups sibling tools, but the verb 'List' and the filter dimensions make the tool's role reasonably complete.

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

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

Schema coverage is 100%, but the parameter descriptions only say 'integer (optional)', which carries little semantic value. The description adds the meaning that teacherId, groupClassId, and individualClassId are filter dimensions. However, it does not clarify whether the filters are mutually exclusive or combinable, so the added semantic value is modest.

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 verb ('List'), the resource ('access groups'), and the available filter dimensions. It does not explicitly distinguish itself from siblings like AccessGroupsGetDetails, AccessGroupsGetGroupClasses, or AccessGroupsGetIndividualClasses, but the plural 'list' framing makes the primary collection behavior apparent.

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 such as AccessGroupsGetDetails or the more specific AccessGroupsGetGroupClasses/AccessGroupsGetIndividualClasses. The phrase 'optional filters' implies listing use cases, but there are no exclusions, prerequisites, or explicit alternative routing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is established. The description adds the useful pagination trait, which is not present in the annotations. It does not go further to describe response shape, default page size, or any additional behavioral constraints, but the annotation coverage lowers the burden.

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

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

The description is a single, front-loaded sentence with no filler. It states the core operation and the key pagination trait efficiently. 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?

For a simple read-only list tool with only three scalar parameters and supporting annotations, the description is nearly sufficient. It identifies the resource, the grouping criterion, and pagination. It does not describe the returned teacher fields, but given the simplicity and the schema, an agent can invoke the tool correctly without major gaps.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the property descriptions are largely tautological ('integer (optional)'). The tool description itself adds no parameter-level meaning beyond 'paginated', which weakly maps to Skip and Take. The required accessGroupId is not explained in the description but is visible in the schema.

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

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

The description states a specific verb and resource: 'List teachers assigned to an access group'. This clearly conveys what the tool does and broadly separates it from sibling tools that list group classes, individual classes, or access groups themselves. However, it does not explicitly name or contrast sibling alternatives, so it stops short of full differentiation.

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

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

The intended use is implied: when a caller wants the teachers assigned to a particular access group. There is no explicit guidance about when to use this tool instead of related tools like AccessGroupsGetDetails or AccessGroupsGetGroupClasses. The absence of exclusions or named alternatives leaves the routing mostly to inference.

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

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

The description adds meaningful behavioral context beyond the annotations: it explicitly warns that the operation is destructive, explains the effect ('unlinks members from the group'), and states that client-side approval is required. This is exactly the kind of disclosure an agent needs.

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

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

The description is two sentences with no filler. The core purpose is front-loaded, and the warning is placed immediately after, making the critical destructive nature prominent.

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 full schema coverage and annotations, the description covers the essentials: purpose and destructive/approval behavior. It does not mention whether at least one body array is required or what happens if no member IDs are provided, but this is a minor gap given the schema's completeness.

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

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

Schema description coverage is 100%, so the schema already documents each parameter, including the Russian explanations for the body arrays. The description itself adds no parameter-level detail, so the baseline score of 3 applies.

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

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

Description states a specific verb and resource: 'Remove members from an access group.' It clearly conveys the operation, though it does not explicitly differentiate from sibling AccessGroupsAddMembers or AccessGroupsDelete beyond the wording.

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 about when to use this tool versus AccessGroupsAddMembers or AccessGroupsDelete. The intended use is implied by the name and description, but there is no explicit context, alternatives, 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?

Annotations already convey readOnlyHint=true and destructiveHint=false; the description adds no behavioral context beyond restating that the call fetches one book. It does not mention error handling, auth, response shape, or that bodyBookId may be semantically required despite the schema listing it optional.

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

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

A single, front-loaded six-word sentence fully states the operation; no filler or redundancy.

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

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

For a simple read-only getter with one parameter, the basics are present. However, with no output schema, no mention of lookup failure behavior, and no guidance about when the id is required, the description is adequate but not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate; 'by id' correctly identifies bodyBookId as the book identifier. Since this is the only parameter, that is sufficient semantic clarification, though it leaves the exact body/location and optionality to 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?

Description states a specific verb ('Get'), a resource ('book'), and a selection criterion ('by id'), making the tool's role immediately clear. This also differentiates it from sibling list tools like BooksGetBooksPlatform and BooksGetBooksSchool.

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 about when to prefer this tool over the plural BooksGet* alternatives or how to handle optionality. The only implied usage is the noun phrase itself, leaving the agent to infer selection criteria from the sibling names.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description only needs to add context. It adds the platform-wide availability scope, but gives no information about response shape, pagination, or whether full book details are returned. This is moderate value beyond annotations.

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

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

A single, direct sentence contains the verb, object, and scope with no filler. Every word earns its place and the main purpose is immediately visible.

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, read-only tool with safety covered by annotations, the description gives the essential behavior. It omits output format, but with no output schema and a simple list responsibility, this is a minor gap rather than a critical omission.

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 100% schema coverage, so there is no parameter ambiguity to compensate for. The description adds no parameter-specific detail, but none is needed; the zero-parameter baseline of 4 applies.

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

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

The description states a clear action ('List') and resource ('books'), with a scope qualifier ('available on the platform') that suggests a distinction from sibling BooksGetBooksSchool. It does not explicitly name the alternative, so it stops short of full sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus BooksGetBooksSchool or BooksGetBook. The intended selection is only implied by the tool name and the word 'platform', leaving the agent to infer the boundary.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the current-school scope, but it does not disclose the result's completeness, ordering, or response shape beyond what the verb and annotations imply.

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 entire description is one short, front-loaded sentence with no filler. It states the action and scope economically without repeating the tool name.

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

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

With no parameters and annotations covering safety/open-world behavior, the description is nearly complete for invoking the tool. It does not spell out the return value shape, but for a parameterless list operation that omission is minor.

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 accepts zero parameters, so there is no parameter interpretation burden. The description's scope (current school) is the only relevant operational input, and it is stated.

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 and scope: books available to the current school. This clearly distinguishes it from the sibling BooksGetBooksPlatform (platform-scoped) and BooksGetBook (a single book).

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 school-scoped reading materials, and the sibling names hint at alternatives, but there is no explicit when-to-use or when-to-prefer-BooksGetBooksPlatform guidance. The intended usage is understandable but left to inference.

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

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

The annotation readOnlyHint=false indicates mutation, and the description's 'Pin' verb aligns with that, so there is no contradiction. However, the description adds no behavioral context beyond the annotations: it does not mention side effects, whether pinning is idempotent, what happens on repeated pinning, or any permission requirements.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. Every word contributes to identifying the operation, making it highly concise and easy to parse.

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

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

For a simple two-parameter mutation tool, the description is too sparse to fully support correct invocation. It omits what 'pin' means operationally, what the response is, and how the 'book' element is resolved given the provided parameters. The absence of an output schema increases the need for more contextual disclosure, which is lacking.

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 no parameter descriptions, so the description must compensate. It mentions 'lesson' and 'class', which loosely map to bodyLessonId and bodyClassId, but it does not explain the relationship between the parameters, whether both are required, or how the book is identified despite being mentioned.

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 ('Pin'), a resource ('a lesson'), and a target ('a class'), which distinguishes it from siblings like BooksGetBook or GroupClassesGetList. However, the phrase 'from a book' is ambiguous because no book identifier appears in the parameters, slightly reducing clarity.

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 guidance on when to use this tool versus alternatives, nor when not to use it. No sibling comparison or prerequisite context is provided, so an agent is left to infer the appropriate scenario.

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 read-only nature is consistent with annotations (readOnlyHint=true, destructiveHint=false), so there is no contradiction. However, the description adds no behavioral context beyond those annotations: it does not explain what kind of statistics are returned, how the optional IDs affect the result, or what the response contains.

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 only one short sentence, which is concise, but it is under-specified rather than efficiently informative. It front-loads a tautological statement and contains no additional structure or useful 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?

With no output schema, no required parameters, 0% schema description coverage, and no description of what constitutes 'statistics,' this is not enough for an agent to confidently invoke the tool. The read-only annotation and parameter names offer only minimal scaffolding.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not mention bodyClassId or bodyPupilId at all, leaving the agent without any added meaning beyond the bare property names and int64 types in 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 'Get class statistics' is essentially a rephrasing of the tool name ClassesGetStatistics. It identifies a verb and resource at a high level, but 'class statistics' is undefined and the description does nothing to differentiate this tool from sibling class-related tools such as GroupClassesGetDetail or ScheduleGetPupilSchedule.

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 about when to use this tool instead of related class, pupil, schedule, or statistics tools. No prerequisites, exclusions, or alternative selection criteria are provided, so the agent must guess from the name alone.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so the description correctly implies a mutating but non-destructive operation. However, the description adds no behavioral detail beyond the action already implied by the tool name and annotations—no mention of side effects, overwriting behavior, permissions, or validation.

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 with no filler or redundant detail. It is appropriately concise for a simple two-parameter mutation, though it sacrifices useful usage context.

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

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

For a low-complexity tool with two obvious integer parameters, the description is minimally sufficient. However, with no output schema and no note about expected responses, permissions, or where to obtain valid IDs, it leaves some context gaps that an agent would need 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 100%, though the schema descriptions are merely 'integer (required)' and carry little semantic weight. The description implicitly maps classId to the group class and teacherId to the new teacher, but it does not add any explicit parameter-level guidance beyond that.

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 ('Change') and a specific resource ('the teacher assigned to a group class'), clearly conveying the tool's purpose. It distinguishes from IndividualClassesChangeTeacher by explicitly mentioning group classes, though it does not differentiate itself from the broader GroupClassesUpdate 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?

No guidance is given about when to use this tool versus alternatives such as GroupClassesUpdate or IndividualClassesChangeTeacher. The phrase 'group class' implies its scope, but there are no explicit conditions, exclusions, or context for choosing it.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation nature is known. The description merely restates 'create' and adds no side-effect, duplicate-handling, authorization, or response-format context; it does not contradict the annotations, but it also adds no behavioral value beyond them.

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

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

The description is a single short sentence with no wasted words, making it easy to parse. However, it is essentially a paraphrase of the tool name and provides little beyond the minimal purpose, so it is under-specified rather than genuinely information-dense.

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

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

The description does not explain what a group class is, what the access groups or tariff duration fields imply, what happens on success, or how this endpoint relates to the many sibling class-management tools. Required fields are in the schema, but an agent lacks enough domain context to confidently select and invoke this tool correctly.

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

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

Schema description coverage is 100%, with each parameter having a Russian description, so the schema already documents the parameters. The tool description contributes no additional parameter semantics, but because the schema carries the meaning, a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Create') and the resource ('a new group class'), so an agent knows the basic operation. However, it does not explicitly differentiate this from the nearby IndividualClassesCreate or GroupClassesUpdate/Delete siblings; that distinction is carried by the tool name rather than the description.

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 GroupClassesUpdate, GroupClassesDelete, or IndividualClassesCreate. It also does not mention prerequisites such as teacher existence, access group setup, or whether these fields are authoritative, so an agent receives no 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?

Annotations already mark this as destructive, but the description adds meaningful context beyond them: it specifies that the group class is removed and notes that client-side approval is required. No contradiction with annotations.

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

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

The description is very short and front-loads the core action. There is slight redundancy among 'Delete', 'Destructive', and 'removes the group class', but the warning and approval requirement are valuable and 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 simple one-parameter destructive operation with no output schema, this description covers the essential behavior and an important workflow requirement. It could mention side effects or irreversibility, but it is not badly incomplete.

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

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

The schema documents the only parameter, classId, with full coverage. The description does not add extra meaning about the parameter, but with 100% schema coverage the baseline of 3 is appropriate.

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

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

The description clearly states the action and resource: 'Delete a group class.' This is specific enough for an agent to know what the tool does, though it does not explicitly contrast itself with related tools like GroupClassesUpdate or IndividualClassesDelete.

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 or when not to use it. The warning and 'Requires client-side approval' are safety-oriented rather than usage-selection guidance.

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

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

The description aligns with the readOnlyHint and destructiveHint annotations, so there is no contradiction. However, it adds little beyond the annotations besides the 'single group class by id' scope, and it does not disclose error behavior, authorization needs, or response characteristics.

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

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

The description is a single, front-loaded sentence with no filler. It states the resource and the lookup criterion efficiently.

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

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

For such a simple getter, the description is mostly adequate, but it lacks guidance on whether classId is actually required despite the schema saying optional, and there is no output schema or return-value description. Sibling context helps, but some ambiguity remains.

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 fully documents classId, so the baseline is 3. The description mentions 'by id' which maps to classId, but it does not clarify the awkwardness of the schema marking the parameter optional while the description implies an id 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 states a clear verb ('get'), a specific resource ('details of a single group class'), and the lookup key ('by id'). It distinguishes this tool from siblings like GroupClassesGetList and IndividualClassesGetDetail without needing to open the schema.

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

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

The description implies the tool should be used when an agent needs details for one specific group class by its id, but it does not explicitly mention when not to use it or name alternatives such as GroupClassesGetList for lists. The usage context is understandable but not fully spelled out.

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

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

Annotations already convey read-only and non-destructive behavior, so the description adds limited new context. It mentions filters and pagination but does not disclose pagination defaults, result shape, whether filters combine, or any response behavior. With no output schema, the description leaves the runtime contract largely unspecified.

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

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

The description is a single, front-loaded sentence with no filler. It names the action, the resource, and the two key qualifiers (filters and pagination) directly, making it 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?

For a simple read-only list endpoint, the description is minimally adequate: the operation is clear and annotations cover the safety profile. However, it omits pagination behavior, return format, and any distinction from the many sibling tools that also involve group-class or schedule listing, so it is not fully self-sufficient.

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

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

Schema coverage is 100%, so the baseline is 3. The phrase 'optional filters and pagination' adds a useful high-level categorization, but it does not map specific parameters to filters versus pagination, nor does it explain the meaning of 'Search' or behavior of pageSkip/pageTake beyond their names.

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

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

The description states a clear verb ('List') and resource ('group classes'), and signals collection-level behavior with 'optional filters and pagination.' It does not explicitly name a sibling for contrast, but it is unambiguous enough to distinguish from detail, create, update, and delete group-class tools.

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

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

There is no guidance about when to choose this tool over related alternatives such as GroupClassesGetDetail, AccessGroupsGetGroupClasses, or ScheduleGetSchoolSchedule. The intended use is implied by 'List group classes,' but no decision rules, exclusions, or alternative-referencing context 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?

Annotations already indicate this is a non-read-only, non-idempotent, and non-destructive operation. The description adds little beyond 'existing,' and does not disclose partial update semantics, permissions, validation behavior, or effects on associated pupils/schedule.

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 with no filler and the core purpose is front-loaded. It is brief, though it could have included one useful qualifier about which fields are updatable or partial update behavior.

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 update tool, the schema plus annotations provide enough to make a basic call, but important context is missing: whether the body fields are partial updates, what happens to unspecified fields, and how this relates to GroupClassesChangeTeacher. No output schema exists, so return behavior is also not described.

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

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

Schema description coverage is 100%, so the schema documents all parameters. The description adds no additional meaning beyond the schema, which is the baseline situation when coverage is high.

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

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

The description states a specific action and resource: 'Update an existing group class.' It clearly distinguishes from create/delete/get siblings by the 'update existing' framing. However, it does not differentiate from the closely related GroupClassesChangeTeacher sibling, which also updates part of a group class.

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

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

No explicit guidance is provided about when to use this tool versus alternatives. It does not mention GroupClassesChangeTeacher for teacher changes, nor does it state when GroupClassesUpdate should be preferred. The only implied context is that the group class already exists.

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

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

Beyond the mutation implied by readOnlyHint=false, the description discloses a significant side effect: the pupil is activated and consumes the school's tariff quota. It also states the exact failure mode with HTTP 400 and the error message, giving the agent valuable behavioral expectations.

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

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

Four short, purposeful sentences front-load the core operation and then explain side effects and error behavior. There is minimal redundancy and no filler, making the description easy for an agent to parse quickly.

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

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

For a mutation tool with no output schema, it covers the action, the key side effect, the dependency on the school's tariff plan, and the failure response. It does not describe the success return value or repeated-add behavior, but the annotations and schema cover the remaining essential invocation 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?

Input schema coverage is 100%, so the schema already documents both parameters, setting the baseline at 3. The description adds real-world meaning about the activation consequence but does not clarify whether bodyPupilIds may be omitted or how IDs are validated, so it does not rise above the baseline.

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

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

The first sentence states a specific verb ('Add'), resource ('pupils'), and target ('group class'), clearly differentiating it from sibling tools like MarathonAddMarathonNewStudents or AccessGroupsAddMembers. It also adds unique behavioral context about activation and tariff consumption, going beyond the tool name.

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

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

The description clearly frames when this tool applies: adding pupils to a group class, and it surfaces the tariff-limit implication that agents should consider before calling. It does not explicitly name alternatives or when-not conditions, 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?

Annotations already mark destructiveHint=true and readOnlyHint=false, and the description reinforces this with a warning. It adds meaningful context by explaining the exact effect ('unlinks the pupil') and the requirement for client-side approval.

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: the action is front-loaded, and the warning is separate and prominent. There is no filler or redundant restating of the tool name.

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

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

For a simple two-parameter destructive operation, the description covers the action, the destructive nature, the specific unlinking effect, and the approval requirement. It does not mention side effects or when not to use it, but the annotations and clear sibling names cover most of the remaining context.

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

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

Schema description coverage is 100%, but each parameter description is only 'integer (required),' adding no real meaning. The tool description contextualizes classId and pupilId through 'remove a pupil from a group class,' but does not elaborate on their roles beyond their self-explanatory names.

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

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

The description opens with a specific verb and resource: 'Remove a pupil from a group class.' This directly states the operation and distinguishes it from sibling tools like GroupClassPupilsAdd and GroupClassPupilsGetList.

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 intended use is implied clearly by the action and object, but there is no explicit guidance on when to use this versus the sibling add/list tools, nor any mention of prerequisites such as the pupil currently being enrolled.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the pagination behavior and group-class scoping; it does not explain pagination defaults, ordering, or empty-result behavior, so it adds some but not rich 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?

One front-loaded sentence states the action and resource, and the parenthetical '(paginated)' adds the single most important behavioral fact with zero wasted words.

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

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

For a simple read-only list operation with one required ID and two pagination parameters, the description plus annotations and schema cover what an agent needs to select and invoke the tool correctly. It does not specify the exact return shape, but the tool's name and 'List pupils' communicate the result type sufficiently.

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

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

Schema coverage is 100%, so the schema carries the parameter documentation. The description's 'paginated' hints at the role of pageSkip and pageTake, but it does not add semantic detail beyond that; the baseline 3 is appropriate.

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

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

The description states a specific action ('List pupils') and target resource ('group class'), and notes pagination. This clearly distinguishes it from sibling mutations like GroupClassPupilsAdd/Delete and from GroupClassesGetList, which lists classes rather than pupils.

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 intended use is evident from the direct phrasing: retrieve pupils belonging to a group class, using pagination for large result sets. It does not explicitly enumerate sibling alternatives or exclusions, but the domain context makes when to call it clear.

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

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

Annotations already establish the mutation profile (readOnlyHint=false, destructiveHint=false), so the description does not need to repeat safety. It adds no extra behavioral context such as side effects on schedules, permission requirements, or reversibility, but it transparently states the core state change.

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 filler; the key object ('teacher') and scoping ('individual class') are front-loaded. Every word earns its place.

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

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

The description covers the basic intent and the schema supplies the required IDs, which is adequate for a simple mutation. It is incomplete regarding the optional classLearningLanguage parameter, whose enum values and role in changing a teacher are unexplained, and there is no guidance on side effects.

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

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

Schema description coverage is 100%, so all three parameters have at least nominal descriptions and the baseline of 3 applies. The tool description adds no additional meaning to classId, teacherId, or the cryptic classLearningLanguage enum, leaving the agent to rely on the weak schema text.

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

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

The description names a specific action and resource: 'Change the teacher assigned to an individual class.' Mentioning 'individual' clearly distinguishes it from the sibling GroupClassesChangeTeacher, so an agent can select the right tool without opening schemas.

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 'individual class' gives clear context that this tool is for one-to-one class assignments rather than group classes. It does not explicitly name GroupClassesChangeTeacher or state a when-not-to-use condition, so it falls one step short of full usage guidance.

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

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

Annotations already indicate this is a non-read-only, non-idempotent write, so the basic safety profile is known. The description adds no behavioral context: it does not mention possible failure conditions, whether pupil/teacher must already exist, duplicate handling, or side effects beyond creating the class.

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 minimal waste. The word 'new' is slightly redundant, and the brevity is more minimal than structured, but it is not padded or unfocused.

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 four fully documented parameters, an agent can construct a syntactically valid request. However, the description omits preconditions, response expectations, and whether the optional language parameter has a meaningful default, so the definition is usable but 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?

Schema coverage is 100%, with Russian descriptions for the name, pupil ID, and teacher ID, plus a fully expanded language enum. The description itself provides no additional parameter meaning, so the schema carries the full burden; baseline 3 is appropriate.

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

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

The description clearly states the action ('Create') and the resource ('individual class'), which distinguishes it from the IndividualClassesGet/Update/Delete/ChangeTeacher siblings. However, it is essentially a sentence-form paraphrase of the tool name and adds no semantic depth beyond what the name already conveys.

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 about when to use this tool versus alternatives such as GroupClassesCreate or IndividualClassesUpdate. No preconditions, exclusions, or alternative routing are documented, so an agent must infer usage purely from the tool name.

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

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

Annotations already mark destructiveHint=true, but the description goes beyond this by warning the user, stating that the class is removed, and noting that client-side approval is required. That approval requirement is non-obvious operational context not conveyed by the annotations.

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

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

The description is short, front-loaded with the action, and adds a warning and an approval requirement without filler. The slight redundancy between 'Destructive' and 'removes' is acceptable given the placed emphasis.

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 delete tool, the description plus annotations and schema provide everything needed: what is deleted, that it is destructive, that client-side approval is required, and which classId to provide. No output schema is present, so return-value detail is not required.

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 covers the only parameter classId fully with 'integer (optional)', and the description adds no additional meaning. Given 100% schema description coverage, baseline 3 is appropriate.

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

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

States the specific operation 'Delete' and the resource 'an individual class', which clearly distinguishes the tool from siblings like GroupClassesDelete. Even without the name, the description identifies exactly what it acts on.

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

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

The description implies the tool is for deleting individual classes, and the sibling list includes GroupClassesDelete and IndividualClassesCreate/GetList, so context exists. However, it does not explicitly state when to use this tool versus alternatives or mention 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. However, the description adds no behavioral context beyond the annotations, such as not-found behavior, response shape, or authorization expectations. There is no contradiction.

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

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

The description is one short sentence with key information front-loaded. There is minor redundancy between 'single' and 'individual', but overall it is concise and easy to parse.

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

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

For a simple one-parameter read-only lookup, the description plus annotations and schema are sufficient for an agent to select and invoke the tool. It does not describe the return value in detail, but no output schema exists and 'details' adequately signals the result.

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

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

The input schema already covers 100% of the single parameter with 'integer (optional)'. The description's 'by id' clarifies that classId is the class identifier, but it adds no detail about format, defaults, or behavior when the parameter is omitted.

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 is specific and unambiguous: 'Get details of a single individual class by id' names the verb, resource, and scope. It clearly distinguishes this from list, create, update, and delete siblings in the IndividualClasses 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 'single ... by id' phrasing implies this tool is for retrieving exactly one individual class, but it does not explicitly state when to prefer it over alternatives like IndividualClassesGetList. No exclusions or when-not-to-use guidance is 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?

The annotations already communicate that this is read-only and non-destructive. The description adds minimal behavioral context beyond the list operation itself, and does not explain open-world behavior, response shape, or pagination semantics. It is consistent with the annotations but adds little beyond them.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource, and every word contributes to the 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?

For a simple read-only list tool with all optional parameters, the description plus schema and annotations is largely sufficient. The lack of an output schema means a brief note on what fields are returned would have improved completeness, but it is not critical for basic 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 100% description coverage for all six optional parameters, so the structural burden is already satisfied. The description only adds the high-level notion of 'filters and pagination' without detailing any individual parameter semantics.

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

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

The description clearly states the verb 'List' and the resource 'individual classes', and adds 'optional filters and pagination' to define the operation's scope. It is clear enough to distinguish from IndividualClassesGetDetail, though it does not explicitly name the sibling alternatives.

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

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

The description implies this tool is for listing individual classes with optional filters and pagination, but it gives no explicit guidance on when to prefer this over related tools like IndividualClassesGetDetail or AccessGroupsGetIndividualClasses. The usage context is present but left implicit.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the agent knows this is a non-read mutation. The description adds no extra behavioral context such as partial-update semantics, idempotency effects, permission requirements, or what happens when the class does not exist. It merely restates the mutation implied by the annotations.

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

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

The description is a single concise sentence with no filler words. It is front-loaded with the action and resource, 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?

For a simple three-parameter update with full schema coverage and safety annotations, the description is minimally sufficient to identify and invoke the operation. However, it lacks important contextual details like update semantics (partial vs. full), the distinction from IndividualClassesChangeTeacher, and expected behavior when the target class does not exist.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already explains that classId is required, bodyName is the new individual class name, and bodyLessonTariffDurationId identifies the tariff that determines lesson duration. The description itself adds no parameter-level meaning beyond the schema.

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

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

The description states a clear verb and resource: 'Update an existing individual class.' It distinguishes from create, delete, and get operations on individual classes, but it does not differentiate from the sibling IndividualClassesChangeTeacher, which is also a kind of update. It is clear but lacks explicit sibling differentiation.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention that teacher changes should go through IndividualClassesChangeTeacher, or that this tool is for updating name and lesson tariff duration. The usage context is entirely left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. However, it adds no behavioral context beyond the word 'List' and the pupil/class scope already visible in the schema; pagination, ordering, updatedAfter behavior, and result shape are not disclosed.

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

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

The description is a single front-loaded sentence with no filler. It communicates the core action and scope efficiently, even if it sacrifices behavioral detail.

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

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

With read-only annotations and a simple required-field schema, the description is minimally sufficient for a basic call. But the optional updatedAfter filter is unexplained, no output schema is provided to clarify return shape, and pagination/ordering behavior 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?

Schema description coverage is 100%, so the baseline is 3. The description adds minimal semantic grouping for pupilId and classId, but it does not clarify updatedAfter beyond the schema's uninformative 'string (optional)'.

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 concrete action ('List') on a specific resource ('lesson packages') with a scope ('for a pupil and/or class'), and clearly separates it from mutation siblings like LessonPackagesSetPackage and LessonPackagesWriteOffLessons. However, 'and/or' is somewhat ambiguous because the schema requires both pupilId and classId.

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

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

The use case is implied: call this when you need to retrieve lesson packages. It gives no explicit when-to-use vs alternatives and no exclusion criteria, leaving the agent to infer that the sibling write tools are not for listing.

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

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

Annotations already signal readOnly=false and idempotent=false, and the description just says 'Set', adding little beyond that mutation occurs. It doesn't disclose whether an existing package is overwritten, whether billing is affected, or what side effects follow, so there is minimal added 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 front-loaded sentence with no filler or repetition. It is concise, though at the cost of omitting useful 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?

With 8 parameters, no output schema, and only minimal annotations, the description is too sparse to fully steer an agent. It doesn't explain return values, preconditions, effects on existing package assignments, or how body fields relate to the package.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself doesn't clarify the body fields, but the schema already documents them, even though some entries are terse (e.g. 'integer (required)' for pupilId/classId).

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 verb 'Set' with the resource 'lesson package' and names the target ('a pupil and class'), which makes the core action reasonably specific. It doesn't contrast with sibling tools such as LessonPackagesUpdatePackagePeriod or LessonPackagesWriteOffLessons, so it lacks explicit differentiation.

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

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

There is no guidance on when to use this tool instead of related package tools. The one-sentence description gives no conditions, prerequisites, or exclusions, so the agent must infer usage entirely from the tool name.

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

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

Annotations already indicate a non-read-only, non-idempotent, non-destructive operation. The description adds no behavioral detail beyond 'Update', such as whether existing period settings are overwritten, how optional fields like bodyComment or bodyToDate affect the update, or any permission or side-effect requirements.

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

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

The definition is a single direct sentence with no redundant phrasing or filler. It is concise and front-loaded, though its brevity leaves important semantic gaps.

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 five parameters, three required, no output schema, and no usage guidance, this one-sentence description is insufficient for an agent to know what 'period' means, which fields matter, or what happens on success. The surrounding sibling names imply broader package-management context, but the description does not connect to 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 description does not clarify which parameters correspond to the 'period' being updated. Schema descriptions are weak: classId and pupilId only repeat 'integer (required)', bodyToDate and bodyComment lack semantic descriptions, and bodyLessonPackageDurationId is described only in Russian. The description fails to bridge the gap.

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

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

The description names a specific action ('Update'), a resource ('lesson package'), and the target aspect ('period'), so an agent can infer the core operation. However, 'period' is somewhat ambiguous and the description does not distinguish this tool from the sibling LessonPackagesSetPackage or LessonPackagesWriteOffLessons.

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 usage context is provided: the description does not state when to use this tool instead of LessonPackagesSetPackage, LessonPackagesGetList, or other sibling operations. There is no mention of prerequisites, target scenarios, or excluded 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?

Annotations already mark the tool as destructive, and the description adds useful specifics: it decrements lesson balance and requires client-side approval. This goes beyond the structured hints, though the mechanics of client-side approval are not elaborated.

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: one sentence states the core action, and the warning follows immediately. Every sentence earns its place with no filler.

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

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

For a destructive mutation with 5 required parameters, the description captures the essential effect and approval requirement, while parameter semantics are fully covered by the schema. The lack of an output schema makes omitting return-value details less critical, though the approval flow remains somewhat vague.

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

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

All 5 parameters have schema descriptions, so the baseline is 3. The description does not add parameter-level detail, though 'decrements lesson balance' indirectly clarifies the meaning of bodyCount.

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 phrase 'Write off lessons from a package' states a specific verb and resource, immediately distinguishing this from siblings like LessonPackagesGetList, LessonPackagesSetPackage, and LessonPackagesUpdatePackagePeriod. The action 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?

Usage is implied by the action name: use this when lessons need to be decremented from a package. The warning adds an important prerequisite of client-side approval, but no explicit alternatives or when-not-to-use guidance 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?

Annotations declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, indicating this is a non-idempotent mutating operation, but the description adds no behavioral details beyond that. It doesn't state whether existing durations can be overwritten, whether duplicates are allowed, or what the response contains. The description adds almost no behavior beyond the annotations, so it doesn't exceed the baseline.

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 a clear verb+object structure. It is appropriately concise for the purpose, though it could benefit from a brief note on usage or required 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 tool has 5 parameters and no output schema, plus a mutating action, the description is somewhat thin. However, the schema covers all parameters and the operation is straightforward: adding a duration option to a tariff. With no output schema, the description doesn't need to explain returns. The missing piece is usage context, but the description is adequate for a simple add 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?

Schema description coverage is 100%, with the description array covering all five parameters. The schema descriptions are in Russian and provide field-level meaning (e.g., bodyDuration = 'Продолжительность лекций в минутах в пакете'). The tool description itself adds no parameter context, but because the schema fully covers semantics, the baseline of 3 applies.

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

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

The description 'Add a duration option to a lesson tariff' clearly identifies the action (add) and resource (lesson tariff), making the purpose immediately clear. It doesn't explicitly differentiate from sibling tools like 'LessonTariffsGetTariffDurationList' or 'LessonTariffsDeleteTariffDuration', but the add/read/delete distinction is inferable from the names.

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 context about when this tool should be used versus alternatives. It doesn't mention that it creates a new duration option within an existing tariff, or that it relates to package-like structures with price, lessons count, and expiry period. An agent would have to infer usage from the schema and sibling names.

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

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

Annotations already signal mutation (readOnlyHint=false), non-idempotency, and non-destructiveness, but the description adds no behavioral context beyond restating the creation intent. It does not disclose, for example, whether duplicate names are allowed, whether bodyDurations is processed atomically, or what side effects occur.

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

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

A single, front-loaded sentence states the purpose without filler. It is appropriately concise, though it sacrifices potentially useful behavioral and usage detail.

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

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

For a creating operation with a nested bodyDurations structure and no output schema, the definition lacks outcome information, error behavior, and relationship to related tariff operations such as LessonTariffsAddTariffDuration. An agent cannot tell what a successful response looks like or what constraints apply.

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

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

The input schema provides 100% property-level descriptions for bodyName, bodyDurations, and bodyDescription, so the description does not need to compensate. The description adds no additional meaning about valid values or relationships between parameters, which keeps this at the baseline.

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

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

The description states a specific verb ('Create') and resource ('new lesson tariff'), making the operation unambiguous. It is easily distinguishable from sibling tools such as LessonTariffsGetList, LessonTariffsDelete, and LessonTariffsAddTariffDuration.

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 about when to choose this tool over LessonTariffsAddTariffDuration or other LessonTariffs operations. There is no mention of prerequisites, exclusions, or use-case context, so an agent must infer the correct selection from the name alone.

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

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

The description adds meaningful context beyond the annotations: it explicitly warns that the operation is destructive, states what is removed ('the tariff'), and discloses the client-side approval requirement. Annotations already indicate destructiveHint=true, but the description enriches that with concrete behavioral expectations.

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: the operation is stated first, followed by a clear warning. Every sentence earns its place, and the destructive warning is prominent.

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 single-parameter delete operation, the description covers the core requirement: the action, the destructive nature, and the approval step. It does not mention success/error behavior, but the annotations and schema cover enough for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds no semantic meaning for lessonTariffId beyond the schema's weak 'integer (required)' text; it does not explain how to identify the tariff or where the ID comes from.

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

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

The description states a clear verb and resource: 'Delete a lesson tariff.' It is distinct from direct sibling deletion tools like LessonTariffsDeleteLessonPackage and LessonTariffsDeleteTariffDuration by naming the tariff itself, though it does not explicitly call out those distinctions.

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 guidance on when to use this tool versus the many sibling tools that also delete related lesson-tariff entities (e.g., LessonTariffsDeleteLessonPackage). The destructive warning is relevant but does not help an agent choose between alternatives.

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

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

The description adds meaningful behavioral context beyond the annotations: it warns that the operation is destructive, explicitly states that it removes the lesson package, and notes that client-side approval is required. This goes beyond the raw destructiveHint and readOnlyHint flags.

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 every sentence earns its place: the first states the action and target, the second adds a critical safety warning and approval requirement. There is no filler or redundant repetition of schema information.

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

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

For a straightforward delete operation with all three required parameters being IDs, the description and annotations together provide sufficient context. It covers destructive behavior and approval requirements, and no output schema is needed for a typical delete response. Minor missing details about side effects would be unnecessary for this 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?

Schema description coverage is 100%, but the parameter descriptions are purely tautological ('integer (required)'). The tool description does not explain the meaning or relationships of the three IDs, although for a delete-by-ID operation the names are largely self-explanatory. This matches the baseline for high schema coverage.

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

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

The description uses a specific verb ('delete'), a clear resource ('lesson package attached to a tariff'), and immediately distinguishes this action from sibling tools like deleting a tariff or deleting a tariff duration. There is no ambiguity about what operation will be performed.

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 this tool is relevant by specifying that it deletes a lesson package attached to a tariff, which contrasts with related tariff deletion tools. However, it does not explicitly name alternatives or state conditions for choosing another tool, leaving usage guidance mostly inferred.

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

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

Annotations already declare destructiveHint=true, but the description goes further by specifying that the operation removes the tariff duration and, notably, requires client-side approval. This adds practical behavioral context beyond the structured 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?

The description is brief and front-loaded with the core purpose. The warning is slightly redundant with the tool name and destructiveHint, but it earns its place by adding the client-side approval requirement and emphasizing the destructive nature for an AI agent.

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 straightforward deletion with two fully covered parameters, the description provides the key operational caveats: destructive behavior and client-side approval. No output schema exists, but for this simple operation the description is sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline applies. Both parameters are documented as required integers, but the description does not explain the semantic difference between LessonTariffId and LessonTariffDurationId. Description adds no value here 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?

Description uses a specific verb ('Delete') and a precise resource ('a tariff duration'), clearly distinguishing this from sibling tools like LessonTariffsDelete (which deletes a tariff as a whole) and LessonTariffsAddTariffDuration (which adds one). The resource name alone disambiguates the 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?

No explicit guidance on when to use this tool versus alternatives, and no mention of sibling tools such as LessonTariffsGetTariffDurationList for finding the correct duration or LessonTariffsDelete for removing the entire tariff. Usage is only implied by the verb and resource 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?

The annotations already declare the tool read-only and non-destructive. The description adds useful behavioral context by mentioning pagination and a soft-deleted filter, but it does not clarify the default deleted behavior, pagination defaults, or what the response represents. No contradiction with annotations.

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

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

A single front-loaded sentence containing the verb, resource, and two key behavioral qualifiers. There is no filler, repetition, or structural overhead.

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 all-optional read operation, the description is adequate to select the tool, and the safety profile is covered by annotations. It is less complete for correct invocation because IsDeleted semantics, Search scope, pagination defaults, and return shape are not described, and there is no output schema to fill those gaps.

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

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

Schema coverage is high, but each parameter description is only a type name repeated, so the schema carries little semantic weight. The tool description adds some meaning by tying pagination to the operation and indicating IsDeleted is the soft-deleted filter, but it leaves Search and the exact pageSkip/pageTake semantics unspecified.

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

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

The description states a specific verb and resource: list lesson tariffs, with pagination and a soft-deleted filter. It is clear enough to identify what the tool does, and the resource noun distinguishes it from sibling tools such as LessonTariffsGetTariffDurationList or LessonPackagesGetList, though it does not explicitly name any sibling.

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

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

Usage is implied: use this tool to obtain a paginated list of lesson tariffs, optionally filtering deleted records. However, there is no explicit guidance about when to prefer this over alternatives, such as fetching tariff durations or packages, and no exclusions are stated.

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

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

Annotations already establish readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safe-read profile is covered. The description adds the pagination behavior, which is useful, but it does not explain defaults, ordering, or how LessonTariffIds affects the result set.

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

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

Six words with no filler, and the pagination qualifier is parenthesized. Every word earns its place; it is appropriately sized for the information it carries.

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 no-required-parameter, read-only list endpoint, the description is nearly sufficient, but with no output schema it leaves return shape, default page size, and the semantics of LessonTariffIds unstated. An agent could invoke it, but would have to infer those 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 100%, earning the baseline 3. The schema descriptions themselves are tautological ('integer (optional)'), and the tool description adds no filtering or pagination semantics beyond the parameter names.

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

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

States a specific verb and resource ('List ... lesson tariff durations') and signals pagination. It does not, however, distinguish itself from the sibling LessonTariffsGetTariffForDurationId or LessonTariffsGetList, so it is clear but not differentiated.

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

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

No guidance on when to choose this over LessonTariffsGetTariffForDurationId, LessonTariffsGetList, or related tariff-duration endpoints. The only context is the parenthetical 'paginated,' which implies list use but offers no exclusions or alternative 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so no safety contradiction exists. The description adds no behavioral context beyond the lookup semantics, such as return shape or error behavior.

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

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

A single front-loaded sentence with no filler; it conveys the operation and the distinguishing key in minimal 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 one-parameter read-only lookup with no nested objects and an output schema absent, the description is nearly sufficient. It would be more complete with an explicit statement of the returned tariff object, but nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% and there is one parameter, so the baseline applies. The phrase 'by its duration id' reinforces that schoolLessonTariffDurationId is the lookup key, 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 states a specific verb ('Get'), a resource ('lesson tariff'), and a lookup key ('by its duration id'), which distinguishes it from sibling tools like LessonTariffsGetTariffDurationList and LessonTariffsGetList.

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 choose this tool over sibling tariff tools, no exclusions, and no mention of alternatives. The intended context is only implied by the name and short 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?

The description goes beyond the annotations by explicitly warning that although this is a GET, it mutates state by inviting students, and that client-side approval is required. This is valuable behavioral context for an agent.

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 front-loaded, but redundant: 'Note: this is a GET that mutates state' and 'WARNING: Mutates state' essentially repeat the same warning. The redundancy costs it a higher 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?

The essential mutation and approval caveats are present, and the main purpose is clear. However, the ModeratorsIds parameter is unexplained, and there is no indication of what the response or side effects look like beyond inviting students. Adequate but with gaps.

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

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

Schema description coverage is 100%, but the parameter descriptions are generic ('array (optional)', 'integer (optional)'). The description adds that the operation is 'by email', hinting at Emails, but does not explain MarathonId, ModeratorsIds, or MailMessageLanguageId beyond what the schema already provides.

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

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

The description clearly states the specific action: adding new students to a marathon by email. It is distinguishable from sibling tools that manage moderators, activation, or student retrieval.

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 makes the use case clear: invite new students to a marathon by email, with client-side approval required. It does not explicitly name alternatives or exclusions, but the context is unambiguous.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description's 'WARNING: Destructive' largely restates them. It does add one useful operational detail, 'Requires client-side approval,' but does not explain side effects, reversibility, or consequences of deactivating a pupil.

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

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

The description is two short sentences with no filler. The core purpose comes first, and the warning is placed immediately after, making the important destructive/approval context front-loaded.

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

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

For a destructive mutation with no output schema and zero parameter documentation, the description remains too thin. It does not state required inputs, what the response will be, or the explicit effect of setting bodyIsActivate to true versus false, so an agent may not invoke it confidently.

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

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

Schema description coverage is 0%, and the description only loosely maps 'activate or deactivate' to bodyIsActivate. It does not explain the semantics of bodyPupilId, bodyMarathonId, or how the activate flag controls the operation, leaving the agent to infer meaning from parameter names alone.

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

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

The description states a specific verb ('activate or deactivate') and a specific resource ('a pupil in a marathon'). This activation toggle is clearly distinguishable from sibling tools dealing with moderators or adding new students, so an agent can tell what it does without opening the schema.

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

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

The intended use is implied by the verb phrase: use this when you need to change a pupil's activation state in a marathon. However, there is no explicit when-to-use guidance, no mention of alternatives to prefer, and no conditions under which this tool should be avoided.

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

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

The description adds no behavioral context beyond the action implied by the name and the annotations already declaring readOnlyHint=false. It does not disclose whether duplicate moderator assignments are rejected, whether the teacher must already exist, what side effects occur, or what the response contains.

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 one-sentence description is brief and front-loaded, but it largely restates the tool name and provides no additional framing. It is concise, yet the brevity borders on under-specification rather than deliberate economy.

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 create operation with no output schema, the description is too thin: it does not state what the request body should accomplish, what a successful response looks like, whether both IDs are required, or how this relates to other moderator-management tools. The 100% schema coverage mitigates parameter confusion but not the missing 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?

Schema coverage is 100%: bodyTeacherId and bodyMarathonId each have descriptions ('teacher ID' and 'marathon ID'), so the schema already carries parameter meaning. The description itself adds no parameter-level detail, but it does not need to because the schema is sufficient.

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

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

Description states a clear action ('Create') and a specific resource ('a marathon moderator'), which is enough to distinguish it from sibling get/delete tools such as MarathonGetModerators and MarathonDeleteModerator. It does not, however, articulate what creating a moderator means in this domain or contrast it with the set-moderation sibling tools.

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

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

There is no guidance on when to call this tool rather than related siblings like MarathonSetModeratorsForPupil, MarathonSetPupilsForModerator, or MarathonDeleteModerator. The intended scenario must be inferred entirely from the tool name and parameters.

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 annotations already mark the operation as destructive, and the description reinforces it with a WARNING and the statement that it removes the moderator. It also adds the client-side approval requirement, which is operational information the agent would not know from the schema alone.

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, front-loaded with the core action, and places the destructive warning prominently. There is minor redundancy between 'Delete' and 'removes the moderator', but overall it is appropriately sized.

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 critical operational facts—destructiveness, non-read-only behavior, and client approval—are covered by the description and annotations. However, the relationship among the four parameters is not explained, and with no output schema there is no statement about what the caller should expect back.

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

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

All four parameters have schema descriptions and schema coverage is 100%, so the description does not need to repeat them. It does not add extra meaning about how bodyIsSelectAll or bodySelectedPupilsIds relate to the deletion, but the schema already provides basic naming 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 states a specific verb and resource: delete a marathon moderator. It is unambiguous, but it does not explicitly differentiate itself from sibling moderator-management tools like MarathonCreateModerator or MarathonUnsetModeratorsForPupil.

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 phrasing implies the tool is used when a marathon moderator should be removed, and the client-side approval requirement is a useful prerequisite. However, there is no explicit when-to-use or when-not-to-use guidance relative to similar marathon moderator 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the operation is paginated and supports search/folder filtering, which is useful behavioral context not present in annotations. However, it doesn't disclose return format, default page size, or ordering, so it adds only modest context.

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

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

A single, front-loaded sentence. Every part adds information: the action, the resource, and the key capabilities. No filler.

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

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

For a simple read-only list operation with four optional parameters, the description covers the main behavioral dimensions (paginated, search, folder filter) and the schema covers the parameters. It doesn't describe the response shape, but 'List marathons' implies returning marathon entities, and there is no output schema to document.

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 100%, each parameter's description is tautological ('integer (optional)', 'string (optional)'). The tool description compensates by mapping SearchTerm to 'search' and FolderId to 'folder filter', and pageSkip/pageTake to 'paginated', giving the agent actual semantic understanding of the parameters.

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

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

States a specific verb ('List') and resource ('marathons'), with modifiers (paginated, search, folder filter). The resource is distinct from siblings like MarathonGetMarathonStudents or MarathonGetModerators, though it does not explicitly name them.

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

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

No explicit when-to-use or alternatives are mentioned. The only guidance is implied: use when you need to list marathons. It doesn't explain when to prefer this over MarathonGetMarathonStudents or other list tools, nor when to use the search/folder filter.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'List' is consistent with a read-only operation. The description adds no deeper behavioral context such as pagination, result envelope, or filter semantics, but for a simple listing operation the annotations already carry the core safety profile.

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 compact sentence that front-loads the action and resource. Every word contributes to understanding, with no repetition of the tool name and no boilerplate.

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

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

The Filter enum values are left entirely unexplained, and the schema's descriptions are uninformative, so an agent cannot reliably choose the correct filter. There is also no output schema to clarify the return shape, and the description does not address whether MarathonId is required for a meaningful request. Annotations cover read-only safety but not the call semantics needed for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the high-level notion that SearchTerm and Filter correspond to search/filter behavior, but it does not explain the Filter enum values (0–5) or whether MarathonId is truly optional in practice. The schema's own 'string (optional)' and 'integer (optional)' descriptions provide little 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 uses a specific verb ('List') and a specific resource ('students in a marathon'), making its purpose immediately clear. It also distinguishes itself from sibling tools such as MarathonGetModerators and MarathonGetMarathonList by naming the exact entity being retrieved.

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 'List students in a marathon' gives clear context for when this tool is appropriate: whenever a marathon's student roster is needed. It does not explicitly name alternative tools for related cases, such as listing moderators or all pupils, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the 'paginated' behavior; it does not disclose ordering, default page size, or how filters interact with results, but this is acceptable given the annotations.

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

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

A single front-loaded sentence with no filler; every word ('List', 'marathon moderators', 'paginated') carries information. This is an appropriate size for the tool's simplicity.

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

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

For a read-only list tool with no output schema, the description gives the high-level return shape but omits how the optional filters (TeacherId, MarathonId) affect the result, pagination defaults, and any response fields. Since all parameters are optional, an agent can call it safely, but a richer description would make correct filter usage obvious.

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

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

Schema description coverage is 100%, giving the baseline of 3 even though the schema descriptions are only 'integer (optional)'. The word 'paginated' adds meaning to pageSkip/pageTake, but TeacherId and MarathonId filter semantics are left to inference from their names.

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

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

States a specific action and resource ('List marathon moderators') and adds the pagination trait, which is enough to distinguish it from sibling mutators and from MarathonGetMarathonStudents. It does not explicitly contrast with any sibling, but the resource term 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 intended use is implied by the listing verb and resource, but there are no explicit when-to-use conditions, exclusions, or pointers to alternative tools. An agent can infer 'when you need moderators' but not when a sibling like MarathonSetModeratorsForPupil should be chosen.

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

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

The description only says 'Assign', which implies mutation, but it does not add meaningful behavioral context beyond the annotations. It fails to disclose whether the call replaces or appends moderators, how invalid IDs are handled, or any side effects. Given openWorldHint=true and idempotentHint=false, more behavioral detail is needed.

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 filler or redundant content. The action and object are front-loaded, making it immediately scannable for an agent.

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 two documented parameters and no output schema, so the core invocation information is present. However, the description does not clarify the assignment semantics (replace vs. add), and with no output schema the agent cannot anticipate the return value. It is adequate but not complete.

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

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

Schema description coverage is 100%: both bodyMarathonPupilId and bodySelectedModeratorsIds have descriptions. The tool description itself adds no parameter-specific meaning, but the schema already documents the two inputs, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Assign') and clearly identifies both the target ('marathon pupil') and the object being assigned ('moderators'). This explicitly distinguishes it from the inverse sibling MarathonSetPupilsForModerator and from the unset 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 gives no guidance on when to use this tool versus alternatives such as MarathonUnsetModeratorsForPupil or MarathonSetPupilsForModerator. It also does not mention prerequisites, whether the assignment replaces existing moderators, or any conditions that should trigger this call.

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

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

Annotations already indicate this is a non-read-only, non-idempotent mutation, and the description merely restates the assigning action without disclosing whether existing pupil assignments are replaced or merged. It also does not mention authorization requirements, validation behavior, or other side effects consistent with the openWorldHint annotation.

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 and no repetition of schema or annotation information. Every word contributes to identifying the 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?

For a simple three-parameter assignment action, the schema plus description give an agent enough to attempt the call, especially with full parameter descriptions. However, the description omits return behavior, whether the assignment is additive or replacing, and any expectations about which parameters are truly required, so it is only minimally complete.

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

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

Schema description coverage is 100%, so bodyMarathonId, bodyModeratorId, and bodySelectedPupilsIds already document the IDs involved, meaning the description does not need to carry that burden. The description adds little beyond the mapping implied by the tool name and gives no detail about constraints such as whether the pupil list overwrites a previous list.

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 'Assign pupils to a marathon moderator' uses a specific verb and names both the resource (pupils) and the recipient (moderator), so the operation is immediately clear. It also semantically differentiates this tool from siblings like MarathonSetModeratorsForPupil, which is the reverse direction, and MarathonUnsetPupilsForModerator, which is the removal 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 gives no guidance about when to prefer this tool over closely related siblings. There is no mention of when to use this versus MarathonSetModeratorsForPupil or MarathonUnsetPupilsForModerator, nor any prerequisites or conditions that should hold before invoking it.

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

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

Annotations already flag destructiveHint=true, but the description adds meaningful context beyond that: it states that moderators are unlinked from the pupil and that client-side approval is required. This helps an agent understand the real-world consequence and prerequisite before invoking the tool.

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

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

The description is extremely concise: one clear action sentence followed by a warning sentence. Every word earns its place, and the destructive warning is front-loaded for visibility.

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

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

For a two-parameter destructive operation with annotations and full schema descriptions, the description covers the core action, its destructive nature, and the approval requirement. It does not describe return values or further side effects, but for this simple mutation with no output schema, the provided context is largely sufficient.

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

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

Schema description coverage is 100%, so the parameters are already documented with meaningful descriptions in the input schema. The tool description does not add further parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Unassign moderators from a marathon pupil.' This clearly identifies the action and object, and it distinguishes the tool from siblings like MarathonSetModeratorsForPupil and MarathonUnsetPupilsForModerator by stating the direction of the 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 intended use is implied by the verb 'Unassign' and the resource phrase, but there is no explicit statement about when to choose this tool over alternatives such as MarathonSetModeratorsForPupil or MarathonUnsetPupilsForModerator. It provides clear context for the operation but no explicit when/when-not guidance.

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

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

Annotations already declare destructiveHint=true, so the description adds value by specifying the concrete consequence: it unlinks pupils from the moderator. It also warns that client-side approval is required, which is useful behavioral context beyond what the annotations provide.

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 front-loaded with the main action, followed immediately by the destructive warning and approval requirement. There is minor redundancy between 'Unassign' and 'unlinks', but the text contains no filler or unnecessary detail.

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

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

For a destructive tool with four parameters and no output schema, the description captures the core effect and approval requirement. However, it does not clarify the selection logic, such as whether bodySelectedPupilsIds is needed when bodyIsSelectAll is false, or what the response/return state looks like. This is adequate but 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?

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no param-level guidance, particularly around the relationship between bodyIsSelectAll and bodySelectedPupilsIds, but it is not required to duplicate schema text.

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, 'Unassign', and a clear resource, 'pupils from a marathon moderator'. It reads as a natural-language version of the tool name, and an agent can tell it targets the pupil-to-moderator link. It does not explicitly differentiate itself from the sibling MarathonUnsetModeratorsForPupil, so it earns 4 rather than 5.

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

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

There is no guidance about when to use this tool versus alternatives such as MarathonSetPupilsForModerator or MarathonUnsetModeratorsForPupil. The action verb implies the purpose, but no conditions, prerequisites, 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?

The description is consistent with annotations (readOnlyHint: false, idempotentHint: false, destructiveHint: false) but adds little beyond what the annotations already convey. It does not mention return behavior, duplicate handling, required email validation, permissions, or side effects.

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

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

The description is one short, front-loaded sentence with no filler or redundant elaboration. It is concise and easy to parse, though it is so minimal that it borders on restating the tool name.

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

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

Given the rich schema and annotations, the description is sufficient for selecting the tool for a straightforward create operation. However, it lacks context about the response format, failure conditions, or how this create operation relates to the broader Pupils toolset, which would make it more complete.

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

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

The input schema has 100% coverage with descriptions for all 16 parameters, so the baseline is 3. The description itself adds no parameter-level meaning; all semantic weight is carried by the schema, which is sufficiently detailed.

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 operation (create) and the resource (pupil), which distinguishes it from sibling tools like PupilsGetList, PupilsUpdate, and PupilsDelete. However, it is minimal and does not specify any additional scope or nuances beyond the simple verb–resource pair.

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 related tools such as PupilsUpdate or MarathonAddMarathonNewStudents. The description relies entirely on the verb 'Create' to imply usage, with no explicit alternatives 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?

Annotations already mark destructiveHint=true and readOnlyHint=false, but the description adds meaningful behavior beyond that: the pupil is permanently removed, client-side approval is required, and upstream returns HTTP 400 if class links remain. No contradiction exists.

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

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

The main action is front-loaded and the prerequisite, error behavior, and approval warning are packed into a few short sentences. It loses one point because 'WARNING: Destructive: removes the pupil' somewhat redundantly restates both the opening sentence and the destructiveHint annotation.

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 destructive tool with no output schema, the description covers everything needed to call it correctly: what it does, the required precondition, which sibling tools to use first, the error to expect, and the approval requirement.

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

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

Schema description coverage is 100% because pupilId has a description ('integer (optional)'), so the baseline is 3. The tool description does not add explicit parameter semantics, but the property name plus 'Delete a pupil' makes the intended use of pupilId clear enough.

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

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

The description opens with a clear verb and resource: 'Delete a pupil.' It also distinguishes this operation from related actions by naming GroupClassPupilsDelete and IndividualClassesDelete as the unlink steps, making the tool's unique responsibility obvious.

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

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

The description explicitly states when deletion is possible: only after the pupil is unlinked from all classes. It names the exact alternative tools to use for unlinking and warns about the HTTP 400 failure mode, giving the agent concrete sequencing guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the behavioral detail of cursor-based pagination, which is useful, but it doesn't explain ordering, page traversal (cursorAfterId/cursorBeforeId), or how filters like OnlyUpdated/OnlyUnchanged behave. Minimal added context beyond annotations.

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

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

A single sentence with no filler or redundancy. It front-loads the core action and pagination style. 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?

With 10 optional parameters, no output schema, and no description of how to page or what the response contains, the definition is under-specified. An agent cannot tell from the description how to correctly invoke cursor pagination or combine filters. The minimal purpose statement is not enough for a tool of this 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?

Schema description coverage is 100%, so the baseline is 3 even though the description itself adds no parameter semantics. The schema parameter descriptions are minimal ('string (optional)' etc.), and the tool description doesn't clarify the meaning or purpose of parameters like Search, OnlyUpdated, or UpdatedAfter. The description does not compensate for the thin schema descriptions, but per the baseline rule the score remains 3.

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

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

The description uses a specific verb ('List') and resource ('pupils') and adds the pagination mechanism ('cursor-based'), which clearly differentiates it from the sibling PupilsGetList. It is a specific, non-tautological statement of what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives such as PupilsGetList or PupilsGetDetail. It doesn't mention whether cursor-based pagination is preferred for large result sets or discuss any filtering conditions. No explicit when-to-use or when-not-to-use information is present.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context beyond that, such as behavior for missing ids, response shape, or any special semantics. With no output schema, this leaves a 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 eight-word sentence with no filler. It is front-loaded with the key action and resource and earns every word.

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, annotated, read-only tool this is minimally viable, but 'details' is vague and there is no output schema or guidance on failure behavior. The absence of explicit alternatives and response expectations makes it adequate rather than complete.

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

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

Schema coverage is 100% but the property description 'integer (optional)' adds no real semantics beyond type and optionality. The tool description confirms pupilId is the identifying id, but that is already evident from the tool name, so no meaningful extra meaning is provided.

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') with a specific resource ('details of a single pupil') and identifies the selection mechanism ('by id'). This clearly distinguishes it from list-style siblings like PupilsGetList and PupilsGetCursorList.

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 'by id' phrase implies this tool is for fetching one specific pupil when its id is known, but it does not explicitly state when to choose it over PupilsGetList, PupilsGetCursorList, or other sibling tools. Usage is implied rather than clearly guided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds that search, filtering, and pagination are supported, but it does not disclose behavioral details such as default page size, ordering, or how OnlyUpdated and OnlyUnchanged interact.

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 wasted words. It conveys the core operation and the main parameter categories efficiently.

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

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

For a list endpoint with eight parameters and no output schema, this description is minimally viable but thin. The parameter names are mostly self-explanatory and annotations cover the read-only behavior, yet the description omits details about pagination behavior, filter semantics, and the response shape.

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

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

Schema description coverage is 100%, which sets the baseline at 3. The description groups parameters into 'search', 'filters', and 'pagination', adding a little semantic structure, but it does not explain individual parameters beyond what their names already convey.

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', the resource 'pupils', and the core capabilities: search, filters, and pagination. It does not explicitly differentiate from the sibling PupilsGetCursorList, but the basic purpose is unmistakable.

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

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

The description implies when to use the tool—when a filtered, paginated list of pupils is needed—but it gives no explicit guidance about alternatives such as PupilsGetCursorList or PupilsGetDetail. An agent would have to infer the selection criteria from tool names.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the write nature is covered. The description adds no additional context about side effects, error behavior, partial-update semantics, or the requirement of pupilId for identification. No contradiction, but no value beyond annotations.

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

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

A single, direct sentence with no redundant words. It is front-loaded and readable, though arguably too terse for a 16-parameter tool.

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

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

For a tool with 16 parameters, four enums, and no output schema, a one-sentence description is insufficient. It doesn't clarify whether unspecified fields are left unchanged, what the response looks like, or any constraints beyond the schema. The agent must rely entirely on schema details.

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

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

Schema description coverage is 100%, so the schema documents all 16 parameters in detail, including enums. The description itself doesn't mention parameters, but with full coverage the baseline is 3.

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

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

States a specific verb ('Update') and resource ('existing pupil'). Clearly distinguishes from sibling tools like PupilsCreate, PupilsDelete, and read-only getters. However, it doesn't enumerate which fields are updatable, so it is not maximally informative.

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 verb 'Update' implies its purpose, but there is no explicit when-to-use guidance or mention of alternatives such as PupilsCreate or PupilsDelete. No exclusion criteria or usage context is 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?

Annotations already report readOnlyHint=false, idempotentHint=false, and destructiveHint=false; the description merely restates mutation with 'Create'. It adds no additional behavioral context such as duplicate handling, ownership, return behavior, or side effects beyond what annotations already imply.

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 redundancy. It is appropriately concise, though it could have used the available space to add one or two high-value behavioral 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 one-parameter create operation with no output schema, the description and annotations together provide the essential operation and mutation profile. However, the return value, duplicate-tag behavior, and any uniqueness constraints are left unstated, so completeness is adequate but not strong.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the schema's parameter description is only the tautological 'string (required)'. The description itself adds no meaning beyond the parameter name TagName, which is reasonably self-explanatory.

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

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

The description clearly states the action ('Create') and the resource ('a new pupil tag'), making it easy to distinguish from siblings like PupilTagDelete and PupilTagGetList. It lacks any additional scoping or relationship detail, so it is clear but not exceptionally informative.

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 verb-resource phrasing implies use whenever a new pupil tag must be created, but it does not state prerequisites, exclusion conditions, or how this tool relates to other create/list/delete tag tools. This is minimum viable guidance for a simple CRUD operation.

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