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

Annotations already convey destructiveHint=true坍 readOnlyHint=false and idempotentHint=true, so the safety profile is known. The description adds no extra behavioral context beyond the basic 'Remove users' action, such as what happens to related assignments or permissions. It does not contradict 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, well-structured sentence with no filler. It leads with the verb and resource, then specifies the input format, making it easy to scan and 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 destructive tool with no output schema, the description is mostly complete. Combined with the annotations and schema, an agent can understand what the tool does and what arguments to supply. It lacks explicit guidance on side effects, but that is adequately covered by destructiveHint and idempotentHint.

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 both parameters ('class' and 'users') are already documented. The description's phrase 'by their user identification strings' only reiterates what the schema already states about the 'users' parameter, adding no new meaning.

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

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

The description uses a specific verb 'Remove' with a clear resource 'users from a class' and a method 'by their user identification strings'. This unambiguously distinguishes it from sibling operations like edubase_post_class_members (adds users) and edubase_get_class_members (lists 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 when-to-use or comparison with alternatives is provided. The purpose is implied by the name and description, but the agent is not told that this is the counterpart to edubase_post_class_members or when to prefer it over edubase_delete_user_classes. No exclusions are mentioned.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description aligns with them (no contradiction). However, the description adds no behavioral context beyond the annotations — it doesn't disclose reversibility (re-adding via post_content_permission), behavior when the permission doesn't exist (despite idempotentHint), or downstream effects of revoking a user's access.

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 — the verb and object come first, followed by the content-type list. The enumeration is slightly redundant with the schema enum, which keeps it from a 5, but every sentence earns its place.

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

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

For a destructive 4-parameter tool with 100% schema coverage, an output schema, and safety-relevant annotations, parameter-level completeness is satisfied. The residual gaps are operational: no statement about what happens when the last permission is removed, whether removal is reversible, or any caveats about permission hierarchy. Adequate but with clear behavioral 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. The prose enumeration of content types mirrors the schema's type enum and adds no format or syntax details beyond it. The 'finances only for events' caveat is already in the schema's permission property, so the description contributes nothing beyond the structured fields.

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

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

The description uses a specific verb ('Remove') with a specific resource ('a permission level of a user from a content') and enumerates all ten supported content types. It clearly differentiates from the sibling tools edubase_post_content_permission and edubase_get_content_permission by verb and direction of 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 guidance on when to use this tool versus the post/get permission siblings, and no prerequisites are stated (e.g., whether the permission must currently exist, or whether removal is the right operation versus downgrading a permission). The only usage signal is the verb in the name and 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?

Annotations already declare destructiveHint and readOnlyHint, and the description adds the specific behavioral detail that the tag itself is retained after removal, which is not evident from the annotations. This provides meaningful extra context about the operation's 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 a single, well-structured sentence with the primary action front-loaded. It lists all content types efficiently and includes the essential behavioral note without any fluff or redundant phrasing.

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

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

For a simple three-parameter tool with full schema descriptions and an existing output schema, the description covers the essential purpose and key behavioral nuance. It does not discuss error cases or prerequisites, but these are adequately implied by the annotations and schema, so the definition 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 coverage is 100%, with each parameter described (tag identification string, type enum with explanations, content identification). The description merely restates the content types in natural language without adding new meaning beyond the schema, so it meets the baseline but does not exceed it.

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

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

The description clearly states the verb 'Remove' and the resource 'a tag from a content', enumerates all supported content types, and adds the key nuance that the tag itself is kept, which distinguishes it from deleting the tag. This differentiates it from sibling tools like delete_quiz or delete_exam.

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

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

The description implies the usage scenario—removing a tag from a specific content type—and the 'tag itself is kept' note clarifies the operation's scope. However, it does not explicitly mention when to use this tool versus adding a tag (post_content_tag) or listing tags, leaving some inference to the agent.

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 the archive fallback and the user-confirmation requirement, which are not present in the annotations (which only state destructiveHint, idempotentHint, readOnlyHint). This is meaningful behavioral context. It doesn't detail reversibility or related-data effects, but annotations already cover the destructive/idempotent 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?

Two short sentences with no filler; the primary action is front-loaded and the conditional behavior is stated in one clause.

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

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

For a one-parameter destructive tool with annotations carrying the safety profile, the description covers the action, the fallback, and the confirmation requirement. The absence of an output schema and lack of detail on archive vs. delete response are minor gaps for this simple 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%, so the schema already documents the only parameter ('exam identification string'). The description does not add format or source details for the exam identifier, but with full schema coverage the baseline 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 ('an exam'), and goes further by specifying the conditional fallback ('archive it when the user is not allowed to delete it'). This clearly differentiates it from sibling delete tools that target exam subresources (e.g., edubase_delete_exam_autologin, edubase_delete_exam_certificates).

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?

Gives an explicit when-to-use ('Delete an exam') and a conditional alternative ('archive it when the user is not allowed to delete it'), plus a required precondition ('Confirm with the user first'). It does not name sibling alternatives, but no other sibling deletes the exam itself, so the guidance is sufficient.

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

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

Annotations already indicate destructive behavior (destructiveHint: true), and the description adds valuable specifics: 'The PIN code and the shortlink of the exam are removed as well.' This discloses concrete side effects beyond the generic annotation, giving the agent a clearer picture of the operation's impact.

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 consists of two concise sentences: the first states the core action, the second adds the critical side effect. There is no redundant or extraneous information, making it efficiently structured 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 tool with one parameter and no output schema, the combination of description, annotations, and parameter schema covers the essential operational aspects. The description adequately explains the primary effect and key side effects, though it does not mention how to re-enable automatic login or any permission prerequisites, which are minor omissions given the annotations.

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

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

The single parameter 'exam' is fully described in the schema as 'exam identification string', so schema description coverage is 100%. The tool description does not add any additional parameter semantics, which aligns with the baseline score for high coverage.

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

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

The description clearly states the action: 'Disable automatic login for an exam' and specifies the side effect of removing the PIN code and shortlink. This distinguishes it from siblings like edubase_post_exam_autologin and edubase_get_exam_autologin, leaving no ambiguity about its purpose.

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

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

The description does not explicitly state when to use this tool or mention alternatives, such as edubase_post_exam_autologin for enabling login. However, the tool's specific name and action make its use case reasonably implicit, providing minimal guidance beyond the operation itself.

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 idempotentHint=true, covering the mutation and repeat-safety aspects. The description adds specificity about what is removed (branding image and color), which is useful beyond the annotations. However, it doesn't disclose potential side effects, error behavior, or authentication requirements, but these are less critical 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, concise sentence that immediately states the action and object. It is front-loaded with the core behavior and contains no filler or redundant information.

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

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

For a simple delete operation with one parameter, no output schema, and annotations covering destructive/idempotent behavior, the description is sufficiently complete. It states the exact scope (branding image and color) and the target (exam). While it doesn't mention the response format, that's not required without an output schema, and the essential information for invoking the tool correctly is present.

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 for the single parameter 'exam', describing it as 'exam identification string'. The description does not add any further meaning to the parameter beyond what the schema provides, so 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 clearly states a specific verb ('Remove') and resource ('branding image and color') targeted at an exam. It distinguishes itself from sibling tools like edubase_get_exam_branding (retrieval) and edubase_post_exam_branding (set/update) by specifying the removal action, making the tool's purpose unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It doesn't mention that get_exam_branding is for viewing or post_exam_branding for setting, nor does it state any prerequisites or exclusions. The usage is implied by the verb but not articulated.

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 idempotentHint=true, but the description adds crucial context: the configuration is kept, already issued certificates are not revoked, and the lock constraint prevents changes. These are important side effects not covered by annotations. The description does not contradict annotations; it complements them. It provides a clear behavioral model 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 three sentences, each carrying meaningful information. The first sentence states the primary action, the second explains the reversible nature and points to the alternative tool, and the third covers side effects and a constraint. No redundant phrases or filler. The most critical information is front-loaded. It is concise and well-structured.

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

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

For a simple tool with one parameter and an output schema, the description covers all essential aspects: what it does, side effects, reversibility, and a usage constraint. The annotations provide destructive and idempotent hints, and the description fills in the behavioral details. Nothing an agent needs to decide whether to call this tool and how it behaves is missing.

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

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

Schema coverage is 100% with a single parameter 'exam' described as 'exam identification string'. The description adds no additional parameter semantics, but since the schema is fully descriptive, the baseline of 3 applies. The parameter is simple and self-explanatory; no further clarification 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 begins with a clear, specific verb and resource: 'Stop issuing certificates for an exam.' It immediately distinguishes this from other certificate-related tools by explaining the configuration is kept and certificates can be re-enabled later via edubase_post_exam_certificates. It also clarifies it does not revoke already issued certificates, which differentiates it from potential revocation tools. This is unambiguous and fully differentiates from siblings.

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

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

The description explicitly names edubase_post_exam_certificates as the way to re-enable issuance, providing a clear alternative. It also states the lock constraint ('settings cannot be changed while the exam is locked'), which informs when the tool cannot be used. However, it does not explicitly contrast with tools that revoke certificates or with a full exam deletion, but the context is sufficient. The usage guidance is strong but not exhaustive.

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?

Despite the annotations already indicating destructive and idempotent behavior, the description adds valuable context beyond them: it states that built-in fields are kept, that examinee-entered values are retained but hidden, and that the view_results_identifier setting is cleared. These are nontrivial side effects that the annotations do not convey. 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 description is four sentences, each delivering a distinct piece of information: primary action, built-in field exceptions with a pointer to the alternative, data retention behavior, and settings clearance. It is front-loaded with the core action and contains zero filler. Ideal length for the complexity.

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

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

The description completely covers the tool's effects: what is removed, what is kept, what happens to existing values, and what settings are affected. Given only one parameter and no output schema, no additional context is needed for an agent to invoke the tool correctly. The annotations cover the destructive nature, so nothing essential is missing.

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

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

The input schema has 100% description coverage for the single 'exam' parameter, so the schema already fully documents the parameter. The description does not add any extra semantic detail about the parameter itself (e.g., format or constraints). Baseline 3 is appropriate since the schema carries the full 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 opens with a specific verb and resource: 'Remove every custom field of an exam.' It clearly states the scope (all custom fields), differentiates from related tools like edubase_post_exam_fields by specifying what is kept vs. what is removed, and notes the side effect on view_results_identifier. This leaves no ambiguity about 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 explicitly names the alternative tool for a different use case: 'use edubase_post_exam_fields to turn those off' (the built-in fields). This provides clear when-to-use and when-not-to-use guidance, telling the agent that this tool is for removing custom fields while preserving built-in ones, and directing to the sibling for the opposite need.

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 idempotentHint=true, so the destructive nature is disclosed. The description adds no further behavioral context (e.g., whether removal is permanent, cascades to results, or generates notifications), but it does not contradict 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?

Single sentence with no filler; the core action and parameter basis are both stated. Perfectly sized for the simple operation.

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

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

The tool is a simple two-parameter deletion operation with full schema coverage and annotations indicating destructive and idempotent behavior. The description, combined with the schema and annotations, gives an agent everything needed to invoke it correctly; no output schema is 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 100% of parameters with descriptions: 'exam identification string' and 'comma-separated list of user identification strings'. The description repeats the notion of 'user identification strings' but adds no new semantics 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 'Remove users from an exam by their user identification strings' uses a specific verb ('remove') and resource ('exam users'), and clarifies the selector. This clearly distinguishes it from sibling tools like edubase_delete_exam (deleting the whole exam) or edubase_post_exam_users (adding users).

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

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

The description implies usage for removing users from an exam, but it does not explicitly state when to prefer this tool over alternatives such as edubase_post_exam_users (adding users) or edubase_delete_exam (deleting the entire exam). The context of the name and sibling list makes the intended use inferable, but the description itself provides no explicit guidance 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 mark this as destructive (destructiveHint: true) and idempotent (idempotentHint: true). The description adds that it deletes 'an uploaded temporary file and/or its upload link', clarifying the dual scope and the temporary nature of the resource. This goes slightly beyond the annotation hints, providing useful context without contradicting them.

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

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

The description is a single, tightly worded sentence that leads with the verb and object, states the identifier source, and avoids any filler. 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 delete operation with one parameter and no output schema, the description covers what is deleted, how the target is identified, and the relationship to the upload endpoint. It does not explain error handling or permission requirements, but these are not essential for a straightforward destructive action given the annotations already indicate idempotency and destructiveness.

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; the single 'id' parameter is fully described as 'external unique filebin identifier of the uploaded file or temporary file upload link'. The description reiterates this source but does not add new parameter semantics, so the baseline of 3 applies since the schema carries the meaning.

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

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

The description clearly states the action (Delete), the resource (uploaded temporary file and/or its upload link), and the identifier source (the filebin identifier returned by edubase_post_filebin_upload). It distinguishes itself from sibling delete tools by explicitly referencing the filebin upload context, making its purpose unambiguous.

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

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

The description specifies that the tool operates on files identified by the return value of edubase_post_filebin_upload, which tells the agent when to use it (after an upload) and what prerequisite is needed. It does not explicitly contrast with alternatives, but the context of filebin upload/delete is clear enough to avoid confusion with other delete 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?

The annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds the important behavioral requirement of obtaining user confirmation before deleting, which is not captured by the annotations. It does not describe additional side effects, but the destructive nature is already disclosed structurally, so the description adds meaningful context beyond the annotations.

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

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

The description is two short sentences with no unnecessary words. The action is stated first, followed by the critical safety instruction. Every sentence contributes meaning, and the structure is easy to parse quickly.

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

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

For a single-parameter destructive tool with annotations covering safety and idempotency, this description is nearly complete. The only missing context is what happens after deletion or whether there are any cascading effects, but the destructiveHint annotation already communicates the risk. Overall, the agent has enough information 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, with the 'integration' parameter already documented as an 'integration identification string.' The description itself adds no additional parameter-level detail. Since the schema fully covers parameter semantics, the 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 states a clear verb and resource: 'Remove an integration.' This is direct and unambiguous, distinguishing it from sibling tools like edubase_get_integration, edubase_post_integration, and edubase_patch_integration. It is slightly redundant with the tool name since 'delete' and 'remove' are synonyms, but it still clearly conveys the action.

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

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

The description includes an explicit usage requirement: 'Confirm with the user first.' This tells the agent when it is appropriate to invoke the tool and implies a prerequisite before deletion. It does not discuss alternatives or explicitly contrast with related integration tools, but for a destructive operation the confirmation guidance is the most critical usage signal.

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 disclose destructiveHint and readOnlyHint, so the description does not need to restate those. It adds the behavioral requirement to confirm with the user first, but it does not disclose what happens to dependent data, whether deletion is reversible, or what side effects may occur. It contradicts no 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?

Two short sentences deliver the core purpose and a critical confirmation requirement with no filler. The structure is minimal and appropriately 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 one-parameter delete operation with complete schema coverage and annotations indicating destructive behavior, the definition covers the essential invocation details. The only notable gap is the absence of any statement about cascading consequences or what specifically happens to associated organization data, but the confirmation instruction mitigates the risk.

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

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

The single parameter 'organization' has full schema description coverage as 'organization identification string,' so the schema carries the semantic weight. The description adds no additional parameter-level meaning, matching the baseline for full 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 states a specific verb and resource: 'Remove an organization.' This clearly distinguishes it from sibling tools that delete subresources such as organization departments, members, or webhooks. Even though the first phrase repeats the annotation title, the intent 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 instruction to 'Confirm with the user first' is useful operational guidance for a destructive action, but the description does not explicitly state when to choose this over alternatives like deleting an organization department or member. Tool selection must be inferred primarily from the resource name rather than from explicit 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 provide destructiveHint=true and idempotentHint=true. The description adds substantial behavioral context: members are left without a department, lose permissions and competencies, and sub-departments are moved one level up. This goes beyond the annotations and is critical for an agent to understand the destructive consequences 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 two sentences, front-loaded with the main action, and contains no redundant information. Every clause adds value, particularly the side-effect 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 destructive delete operation with two parameters and no output schema, the description covers the essential consequences. It does not mention reversibility, error behavior if the department is not found, or required permissions, but these are partially covered by annotations and not strictly necessary. A small gap 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?

Schema coverage is 100% and both parameters have clear descriptions. The tool description does not add parameter-specific semantics beyond what the schema already provides, 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 states a specific verb and resource: 'Remove department from an organization.' It clearly distinguishes from sibling tools like delete_organization (removes whole org) and delete_organization_members (removes members) by naming the department as the target. The resource and action are unambiguous.

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

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

The description implies usage when one wants to remove a department, and the side effects provide context. However, it does not explicitly mention when to use this tool versus alternatives such as delete_organization or patch_organization_department, nor does it offer exclusions. The usage context is clear but not explicitly contrasted with siblings.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description aligns with these. It adds no extra behavioral context beyond the action itself, such as side effects or prerequisites. With annotations covering the safety profile, the description contributes minimal additional value.

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 concise sentence that front-loads the action and resource. Every word earns its place with no filler or redundancy.

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

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

For a simple two-parameter destructive operation with no output schema, the description is adequate. Annotations cover the destructive and idempotent nature. It doesn't mention irreversible side effects, but those are implied by destructiveHint and the clear 'Remove' action. The description is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, with both parameters described in the schema. The description's mention of 'user identification strings' simply restates the users parameter's schema description. No new semantic information is added beyond what the schema provides.

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

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

The description clearly states the action (Remove), the target resource (users from an organization), and the input method (by user identification strings). This distinguishes it from sibling tools like edubase_delete_class_members (different scope) and edubase_post_organization_members (opposite action). No ambiguity.

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

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

The description implies when to use it (when you need to remove users from an organization) but does not explicitly state when not to use it or mention alternatives. It provides clear context but lacks exclusions or comparisons to similar deletion 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?

The annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds meaningful context beyond these flags by specifying the effect on notifications: 'no more notifications are sent to its endpoint', and by contrasting removal with disabling. It does not explicitly state irreversibility or recreation requirements, but the destructive annotation plus the contrast with patch covers the essential behavior.

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

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

The description is two sentences with no filler. The primary action and consequence are front-loaded in the first sentence, and the alternative tool is given in the second. Every part 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 two-parameter delete operation with annotations covering destructive and idempotent behavior, the description is complete. It states what the tool does, its effect, and the relevant alternative. No output schema exists, so return-value documentation is not required, and the low complexity means nothing critical is missing.

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

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

The input schema already provides 100% description coverage for both parameters, each described as an 'identification string.' The tool description does not add extra meaning about parameter format, validation, or relationships, so it does not exceed the baseline for fully covered schemas.

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: 'Remove a webhook from an organization', and clearly states the behavioral consequence, 'no more notifications are sent to its endpoint.' It also distinguishes itself from the sibling by explicitly naming edubase_patch_organization_webhook as the alternative for merely disabling, so an agent can differentiate the tools.

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

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

The description gives explicit usage guidance: use this tool for removal and edubase_patch_organization_webhook when the intent is 'only disable it.' This directly addresses when to choose this tool versus the closest alternative, leaving little 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 mark destructiveHint=true, but the description adds that the deletion is permanent and cannot be undone, and requires user confirmation. This adds behavioral context beyond the annotations, though it does not elaborate on side effects 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?

Two concise sentences with no filler. The action is front-loaded, followed by irreversibility and confirmation guidance. Every sentence contributes necessary 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 simple one-parameter destructive tool with no output schema, the description covers the core purpose, irreversibility, and user confirmation. There is no missing information an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so the schema already explains the id parameter. The description does not add any additional parameter semantics beyond what is in the schema, meeting the baseline for high coverage.

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

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

The description clearly states the verb 'delete' and the resource 'Quiz question', and specifies it is identified by an external unique question identifier. This is specific and unambiguous, distinguishing it from deleting a quiz or other resources.

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

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

The description includes an explicit instruction to confirm with the user first, which is important for a destructive action. However, it does not mention when to use this tool versus alternatives like edubase_delete_quiz_questions, so it lacks explicit exclusions or 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?

The description discloses two behavioral traits not captured in the annotations: the fallback to archiving when deletion is not allowed, and the requirement to confirm with the user first. Annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=true, but the description adds meaningful context about the conditional behavior (archive vs. delete) and the user-confirmation step. This adds value beyond the structured metadata without contradicting it.

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

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

The description is extremely concise: two short sentences that front-load the primary action ('Delete a Quiz set') and immediately follow with the key fallback and the confirmation requirement. Every word earns its place; there is no fluff or redundancy. It is well-structured 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?

Given the tool's simplicity (one parameter, no output schema) and the annotations covering destructive/read-only/idempotent behavior, the description is fairly complete. It explains what the tool does, the fallback behavior, and the confirmation requirement. It does not describe the return value or post-deletion effects, but with no output schema, that is not required. It also doesn't explain how to obtain the quiz ID, but that is presumably available from other tools (e.g., edubase_get_quiz). Overall, the description is adequate 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 schema describes the single parameter 'quiz' as 'Quiz identification string', which is minimal but sufficient given 100% schema coverage. The tool description does not add any additional parameter semantics, such as format, how to obtain the ID, or expected values. Since the schema already covers the parameter, a baseline of 3 is appropriate; the description adds no extra value for this dimension.

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

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

The description clearly states the tool's primary function: 'Delete a Quiz set', with a specific resource (Quiz) and a clear verb. It also mentions a fallback action ('or archive it when the user is not allowed to delete it') and a required precondition ('Confirm with the user first'), which distinguishes it from read/update tools like edubase_get_quiz and edubase_patch_quiz. The purpose is unambiguous and specific.

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

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

The description provides clear usage context: delete a quiz, with a fallback to archiving when deletion is not permitted, and it explicitly instructs to confirm with the user first. This is a strong guideline for when to invoke the tool. However, it does not explicitly exclude other delete tools (e.g., edubase_delete_quiz_questions) or mention when not to use it, though the tool name largely disambiguates. The confirmation step is a notable usage rule that goes beyond the annotations.

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 destructiveHint and idempotentHint, and the description adds concrete failure conditions: global presets, organization presets, and presets in use by a Quiz or exam cannot be deleted. This goes beyond the structured fields by explaining the boundaries of the deletion 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?

Two sentences, with the action verb and object front-loaded and the constraints in a compact second sentence. No wasted words.

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

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

For a simple one-parameter delete operation, annotations supply the destructive/idempotent profile and the description supplies the key constraint set. The agent has everything needed to select the tool, provide the preset ID, and predict failure conditions.

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

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

The single parameter 'preset' is fully documented in the schema as 'grading preset identification string', and the description doesn't add any further syntax, format, or source guidance. With 100% schema coverage, a 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?

States a specific verb and resource: 'Remove a custom grading preset.' The qualifier 'custom' differentiates this deletion from global or organization presets and from sibling tools such as get_quiz_grading_preset, post_quiz_grading_preset, and patch_quiz_grading_preset.

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

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

The description provides clear scope by listing three categories that cannot be removed, which tells the agent when the tool will fail. It does not explicitly name alternative tools or route to get/patch operations, so it stops short of a full when/when-not guide.

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 destructiveHint=true and idempotentHint=true. The description adds the context that removal can target a specific group, but it does not disclose other behavioral traits like whether removal is permanent or what happens to the question entity itself.

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

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

The description is a single sentence that efficiently conveys the action and scope with no redundant words. It is front-loaded with the verb and object.

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?

While the description covers the basic operation, it lacks details about return values (no output schema), reversibility, or effects on dependent objects. For a destructive tool, more context would be beneficial.

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 basic descriptions for each parameter. The tool description does not add further meaning, such as how to obtain the identifiers or the format required, so it meets the baseline but does not enhance understanding.

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

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

The description specifies the verb 'Remove' and the resource 'question(s) from a Quiz set, or one of its question group', which clearly distinguishes it from sibling tools like edubase_delete_question (which likely deletes the question entity entirely). The scope is precise.

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 edubase_delete_question or other delete tools. It does not mention when not to use it or any 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?

Even with destructiveHint=true in the annotations, the description adds substantial nuance: archiving makes the result disappear from lists/reports but keeps it restorable by adding the user back; forgetting detaches the play from the user but keeps it for statistics. It also discloses admin-only requirement for non-exam results. This goes well beyond a raw destructive flag and gives an accurate mental model of 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?

Five sentences, each essential: main purpose, the two behavioral branches, the archive-enabling prerequisite, the current-result restriction, and the admin-only restriction. The prose is dense but well-structured, with no fluff or redundant restatement of the title/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?

The description fully equips an agent to invoke the tool correctly: it explains what happens in both exam and non-exam scenarios, names the prerequisite setting and its source, notes the current-result limitation, and states permission requirements. Given no output schema exists, the state-change explanation is sufficient; there are no obvious missing critical 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?

The input schema already covers 100% of the parameter with 'play' described as 'Quiz play identification string.' The description does not enrich the parameter's meaning (e.g., how to obtain the play ID or expected format), so the schema does the heavy lifting. Baseline 3 is appropriate.

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

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

The description opens with 'Archive or forget the result of a Quiz play,' providing a clear verb (archive/forget) and specific resource (a Quiz play's result). It then explains two distinct outcome modes (exam result vs. outside exam), making it unambiguous what the tool does and distinguishing it from generic delete_quiz or delete_exam tools.

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

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

The description gives concrete usage constraints: exam results can only be archived when the archive setting is enabled (referencing edubase_post_exam_settings), only the current result can be archived, and non-exam results can only be forgotten by administrators. These communicate when the tool is applicable. However, it does not explicitly point to an alternative tool for a comparable action, so it stops short of a full 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 declare destructiveHint=true and readOnlyHint=false; the description adds value beyond that by specifying which users are eligible for deletion and instructing confirmation with the user first. It does not elaborate on irreversible data loss or what happens to related account data, but the destructive hint covers the core risk.

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

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

Two short sentences with no filler. The action is front-loaded and both additional sentences carry useful constraints that an agent needs before invoking a destructive 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?

For a one-parameter destructive tool with no output schema, the description gives the action, eligibility restriction, and a safety confirmation instruction. It is slightly thin on what the deletion entails beyond the account record, but the annotations cover destructiveness and the simple schema keeps the context manageable.

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

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

Schema documentation covers the single parameter (user, 'user identification string') at 100%, so the schema carries the semantic load. The description adds no additional format, source, or resolution details for the user identifier, so 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 a specific verb and resource: 'Delete a user account.' This clearly distinguishes it from sibling tools that target related but different resources such as delete_user_login, delete_user_classes, and delete_user_organizations.

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

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

Provides explicit eligibility conditions ('Only the users created through the API or generated by the current user can be deleted') and a required confirmation step, which tells the agent when the tool is applicable and when not. No alternative is named, but the exclusion is explicit enough to route correct usage.

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

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

Annotations already mark the tool as destructive, non-read-only, and idempotent, so the description does not need to repeat those traits. It adds only the scoping detail that classes are addressed by identification strings; it does not disclose consequences such as whether user accounts remain intact or whether the removal is reversible.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word earns its place, and the core action 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 low-complexity operation with two well-documented parameters and no output schema, the description is largely sufficient to invoke correctly. The main omission is usage guidance relative to the many sibling membership endpoints, which is already captured in the usage score.

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 fully describes both parameters ('user identification string' and 'comma-separated list of class identification strings'), and the description's phrase 'by their class identification strings' mirrors that documentation. With 100% schema coverage, the description does not add meaningful parameter semantics beyond the schema.

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

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

The description uses the specific verb 'Remove' with a clear resource ('a user from classes') and specifies the input key ('class identification strings'). It is unambiguous on its own, but it does not explicitly differentiate itself from sibling tools like edubase_delete_class_members or edubase_post_user_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 gives no guidance about when to choose this tool over the related membership endpoints (e.g., edubase_delete_class_members or edubase_post_user_classes). It states only what the tool does, leaving the agent to infer its context from the name and sibling list.

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

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

Annotations include destructiveHint=true, indicating mutation. However, the description does not disclose potential side effects, such as whether the link becomes immediately invalid, whether the user's other login links are affected, or whether this is reversible. With no additional behavioral context, the description adds little beyond the annotations, and the destructive nature is 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 a single, concise sentence that front-loads the core action. It contains no filler or redundant information, making it efficient and appropriately sized for a simple 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?

The description is complete enough for a simple two-parameter tool with full schema coverage and no output schema. However, given destructiveHint=true and openWorldHint=true, additional context about the effects and prerequisites would improve completeness. The tool's role in the larger login management workflow is not mentioned, but the core operation is clear.

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

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

Schema description coverage is 100%, with each parameter having a short description ('generated login link to be invalidated' and 'user identification string'). The description does not add further nuance, such as the format of the URL or user string, or any constraints like whether the user must match the link's user. Baseline 3 is appropriate since the schema already documents 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?

The description clearly states the action ('Invalidate a login link') and the resource ('previously generated for a user'). It distinguishes the tool from siblings like edubase_post_user_login (which generates) and edubase_get_user_login (which retrieves), making the purpose unambiguous. However, it could explicitly mention the user association to differentiate from other delete tools.

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

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

The description implies usage: when a login link exists and needs to be invalidated. It does not explicitly state when to use this tool versus alternatives, such as edubase_delete_exam_autologin or edubase_post_exam_users_generate. No exclusions or alternative conditions are provided, leaving the agent to infer based on 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 indicate destructiveHint=true and idempotentHint=true, but the description does not add context about the destructive nature (e.g., irreversible removal, related data loss) or mention idempotency. No additional behavioral information 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?

Single, clear sentence with no unnecessary words. It is appropriately front-loaded with the action and resource. Perfect 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?

With a simple two-parameter tool, no output schema, and full schema coverage, the description is minimal but sufficient for basic use. However, it does not clarify the effect (e.g., whether all memberships are removed) or any constraints, so it's just adequate.

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

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

Schema description coverage is 100%, so both parameters are documented in the schema. The description adds no extra detail beyond 'organization identification strings' and 'user identification string', which mirrors the schema. Baseline 3 applies.

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

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

The description clearly states the action (remove) and the resource (user from organizations), with the specific identifier type (organization identification strings). It distinguishes from sibling tools like post_user_organizations by being the delete counterpart, though it doesn't name them explicitly.

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

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

The description implies this tool is used when a user needs to be removed from organizations, but it does not provide explicit when-to-use vs alternatives or mention any prerequisites (e.g., that the user must already be a member). Context signals have no 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 write operation and non-destructive behavior. The description adds the prerequisite of requesting a link in advance but does not disclose file size limits, overwrite behavior, or error handling. 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?

Single sentence that conveys the core purpose and one key prerequisite. Slightly awkward phrasing ('with a link requested from the API in advance') but overall efficient and front-loaded.

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

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

The description explains input well but lacks any mention of output or return value. Without an output schema, the AI is left guessing what the tool returns. Adequate for a basic upload operation but missing 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 coverage is 100%, so parameter descriptions already exist. The description adds no significant new meaning beyond the schema, only restating that source can be local file or URL.

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 clearly states 'Upload a local file or a file from a URL to the EduBase temporary file storage', specifying the action and target. It also mentions the prerequisite of having a filebin URL, distinguishing it from other 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?

Description implies that a filebin URL must be obtained beforehand but does not explicitly compare to sibling tools like edubase_post_filebin_upload. No 'when to use' 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?

Annotations fully cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the read-only, non-destructive behavior is already known to the agent. The description adds context about what the returned details include but does not disclose error behavior, auth needs, or other behavioral traits beyond the annotated posture. This matches the calibration anchor where annotations carry the burden and the description adds modest scope context.

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

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

A single front-loaded sentence with verb and resource followed by a compact field list. Every word earns its place; nothing is redundant or extraneous.

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 read operation with a full annotation profile and an output schema present, nothing needed for correct invocation is missing. The description carries the selection-relevant information, and the output schema covers return-value 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% — the 'class' parameter is documented as 'class identification string'. The description adds no additional meaning for the parameter itself; it only enumerates the returned fields, so the baseline 3 for high schema coverage 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 uses the specific verb 'Get' with the resource 'class' and enumerates the exact payload ('title, external identifier, and start and end dates'). This distinguishes it from sibling tools like edubase_get_classes (listing), edubase_get_class_members, and edubase_get_class_assignments, which cover different scopes.

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 field enumeration ('title, external identifier, start and end dates') implies this is for basic class metadata, and sibling names (get_class_members, get_class_assignments) hint at alternatives. However, there is no explicit statement of when to prefer this tool vs alternatives or any exclusions, leaving routing 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the status enum and submission period details, which is useful but doesn't disclose pagination, error behavior, or any other behavioral nuance. With annotations covering the core, a 3 is appropriate.

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

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

A single, front-loaded sentence with zero wasted words. It states the action and the output fields efficiently, making it easy for an agent 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?

The tool has an output schema, so return format is handled externally. The description covers the essential purpose and key output fields. It lacks mention of potential edge cases (e.g., empty class) but for a simple read-only list tool, this is adequate.

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

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

The only parameter 'class' is fully described in the schema as 'class identification string' (100% coverage). The description does not add further meaning, so 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 clearly states a specific verb 'List' and resource 'assignments of a class', and enumerates the returned fields (titles, links, status, submission period). It is unambiguous and distinct from sibling tools like get_class_members or get_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?

The description gives no indication of when to use this tool versus alternatives, nor any exclusions or prerequisites. It simply states what it does, leaving the agent to infer usage from the name and context.

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

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

Annotations already cover readOnly, idempotent, openWorld, and non-destructive behavior. The description adds value by stating the exact shape of the response (identification strings, external identifiers, titles), which is behavior not captured by the annotations. No contradictions with annotations were found.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the output details are provided in a single follow-up sentence. Every word serves a purpose.

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

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

This is a simple read-only list operation with three optional parameters, all documented in the schema, and an output schema is available. The annotations cover safety and idempotency. The description provides enough context about scope and return values, so nothing essential is missing for an agent to invoke it correctly.

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

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

The input schema documents all three parameters (page, limit, search) with descriptions, so schema coverage is 100%. The tool description adds no extra parameter-level guidance, which is acceptable given that the schema carries the full burden. This is a baseline score as the description does not need to compensate for schema gaps.

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 ('List owned and managed classes') and clarifies the output ('class identification strings, external identifiers and titles'). This distinguishes it from sibling tools like edubase_get_class or edubase_get_user_classes by specifying the ownership/managed scope.

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

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

The description clearly conveys when to use this tool: to list classes the caller owns or manages. It does not explicitly name alternatives or exclusion conditions, but the resource scope provides sufficient context for selecting it over related class-listing 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?

The description clarifies that 'active' means 'approved and not expired', adding semantic meaning beyond the readOnlyHint annotation. It also implicitly confirms a safe read operation consistent with the annotations, though it does not describe pagination or result shape (output schema exists).

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

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

The description is a single, focused sentence with no wasted words. It state the action, resource, and output clearly, making it 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?

Given a single parameter and an output schema, the description covers the key behavior (listing members with names and active status) and defines a term ('active') that could be ambiguous. It doesn't describe error handling or edge cases, but those are not typically required when an output schema exists.

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 description 'class identification string' is minimal. The tool description does not elaborate on the parameter's format or source (e.g., 'use the ID from get_classes'). Therefore, it meets the baseline but adds no extra 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 explicitly states the action (list), the resource (members of a class), and the output (names and whether membership is active). It is unambiguous and distinguishes this tool as a read operation for class members, not confused with other class-related tools.

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

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

The description gives no guidance on when to use this tool over its many sibling tools (e.g., edubase_get_class, edubase_get_user_classes, edubase_get_class_assignments). It does not mention alternative tools or conditions, leaving the agent to infer usage from the tool name alone.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructiveness. The description adds useful behavioral context by specifying that the tool returns both the user's permission status and whether a permission rule with exactly the given parameters exists, which aligns with and clarifies the openWorldHint. 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?

Two concise sentences front-load the core behavior and follow up with the exact return semantics. No filler or redundant explanation is present.

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 read-only annotations, 100% schema coverage, and an output schema, the description is complete for an agent to invoke the tool correctly. It adds the key semantic of exact-rule matching without needing to duplicate schema or return 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%, and each parameter is already documented with enums and descriptions. The tool description repeats the content type list but adds no meaning beyond the structured schema, so the 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 uses a specific verb ('Check') and resource ('permission level on a content'), enumerates all supported content types, and states the two return concepts. This clearly distinguishes it from the sibling mutation tools edubase_post_content_permission and edubase_delete_content_permission.

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 establishes the use case: checking whether a user has a permission level on a content item, with an explicit note that the result also indicates whether an exact permission rule exists. It does not explicitly name alternatives such as post/delete_content_permission, but the read-only framing and sibling names provide enough context for correct selection.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, covering safety. The description adds no behavioral detail beyond the schema's parameter list. It doesn't state that it returns a boolean or that it's a non-mutating check, but annotations cover that. Minimal value added.

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?

Single sentence, efficient, front-loaded with the verb and resource. Lists all content types without redundancy. No wasted words.

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

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

There is an output schema, so return values are documented structurally. The description is sufficient for a simple boolean check given the annotations cover safety. It doesn't cover edge cases but no major gap is evident.

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 (type, content, tag) are documented in the schema. The description adds no extra meaning beyond clarifying via the enum's inline note ('scorm: SCORM learning material, quiz: Quiz set'). 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 the verb 'check' and resource 'tag attached to a content', listing all supported content types. It clearly distinguishes from siblings like get_content_tags (which likely lists all tags) and post_content_tag (which attaches a tag). However, it doesn't explicitly state the boolean return nature.

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

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

The description implies a read-only existence check but doesn't mention when to prefer it over get_content_tags or post_content_tag. It doesn't state exclusions or alternatives. The openWorldHint annotation signals a read operation, but the description itself lacks explicit usage context.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds no further behavioral detail beyond the basic listing operation, such as pagination, sorting, or authentication requirements. It does not contradict 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 that immediately states the action and scope, with no filler. It is front-loaded with the primary purpose and efficiently lists the supported content types.

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 two well-documented parameters and an output schema present, the description is adequate. It covers the essential content types and the purpose, though it could mention whether results are sorted or if there are any limits, but these are minor gaps given the tool's simplicity.

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% coverage for both parameters (type and content) with descriptive text and an enum for type. The description adds no extra semantic nuance beyond what the schema already states, so 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 states a specific verb ('List') and resource ('tags attached to a content') and enumerates the valid content types, which makes the core purpose clear. It does not, however, distinguish this from the sibling edubase_get_content_tag (singular), which could plausibly retrieve a single tag for a content, leaving slight ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. For instance, there is no mention that edubase_get_tags lists all tags globally, or that edubase_get_content_tag (singular) might retrieve a single tag. An agent is left to infer the distinction from the plural form.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds behavioral context beyond that by enumerating the payload contents and clarifying that settings are excluded from this call, setting accurate expectations about what the agent will receive.

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

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

Two sentences with zero waste: the first delivers the core purpose and payload list, the second routes to the relevant sibling. No redundancy with the annotations or schema; every sentence earns its place.

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

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

The tool is a simple 1-param read operation with rich annotations, full schema coverage, and an output schema that documents return values. The description covers purpose, scope, and the key sibling distinction; nothing an agent needs 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 description coverage is 100% — the single 'exam' parameter is documented as 'exam identification string'. The description adds no additional parameter guidance (e.g., whether the string is an ID, slug, or UUID), so with full schema coverage 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?

States a specific verb ('Get') and resource (details of an exam) and enumerates the exact returned fields: title, language, quiz set, active state, status, times, deadline, and Safe Exam Browser links. It also distinguishes itself from the confusable sibling edubase_get_exam_settings, which is critical given the large sibling list.

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

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

Explicitly routes the agent to edubase_get_exam_settings when settings are needed, providing both an alternative and the condition that selects it. This resolves the most likely source of confusion among the many exam-related tools without leaving anything 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 supply readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by detailing the specific returned data (PIN, links, account behavior), which is useful context beyond the annotation hints. 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 description is a single, well-structured sentence that front-loads the purpose ('Get the automatic login configuration') and then lists the relevant components. Every clause contributes useful information without redundancy or filler.

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

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

The tool is a simple read operation with one fully documented parameter, a rich output schema, and safety annotations. The description covers what the tool returns, and the output schema can define exact return structure. Nothing essential is missing for an agent to invoke it correctly.

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

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

The single parameter 'exam' is fully documented in the schema as 'exam identification string' (100% coverage). The description does not add further detail about the parameter, but with complete schema coverage, the 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 uses a specific verb ('Get') and resource ('automatic login configuration of an exam'), and enumerates exactly what the configuration contains: enabled state, PIN code, login/results links, and account generation/registration behavior. This clearly distinguishes it from sibling mutation tools like post_exam_autologin and delete_exam_autologin.

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 guidance is given. The description never says when to use this tool versus the post/delete autologin siblings, nor does it mention any prerequisites or when a GET is appropriate. The intended use is only implied by the verb 'Get' and the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the specific branding attributes returned, which is useful but not additional behavioral disclosure beyond the annotations.

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

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

The description is a single, compact sentence that front-loads the operation ('Get the branding of an exam') and then efficiently enumerates the key aspects returned. There is no redundant wording or filler.

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

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

For a simple one-parameter read operation with rich annotations, a 100% schema-covered parameter, and an output schema present, this description is nearly complete. It names the resource and the expected returned fields; only an explicit pointer to sibling branding tools is missing, which is a minor gap.

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

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

The single parameter 'exam' is already documented in the schema as an 'exam identification string', and schema description coverage is 100%. The description mentions 'an exam' but adds no format, example, or constraint beyond what the schema already provides, so 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 uses a specific verb ('Get') and names the exact resource ('branding of an exam'), then lists the precise data points returned: enabled state, image type (logo or cover), and branding color. This clearly distinguishes it from sibling operations like post_exam_branding or delete_exam_branding.

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

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

The description implies usage by describing what is retrieved, so an agent can infer it should be called when exam branding information is needed. However, it does not explicitly mention when to choose this over related tools such as edubase_post_exam_branding or edubase_get_exam_settings, nor does it give any exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral nuance beyond that: successful-result dependency on grading, the 'only the state' returned when disabled, and preset merging behavior. This is more than a bare read operation and gives the agent accurate expectations about the response content.

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

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

The description is four sentences and every sentence adds distinct information: the core purpose, the grading prerequisite, the merged-configuration behavior, and the related sibling tool. It is slightly longer than minimal but remains efficient and well-structured.

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

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

For a read-only tool with one parameter and an output schema, the description is complete. It explains the core behavior, the conditional return shape, the prerequisite grading flag, and how to access individual certificates elsewhere. Nothing necessary for calling the tool correctly is missing.

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

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

Schema description coverage is 100%, and the single required parameter 'exam' is documented as 'exam identification string'. The description does not add additional meaning about the parameter itself, but with full 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 opens with a specific verb and resource: 'Get the certificate settings of an exam.' It further distinguishes itself from sibling tools by clarifying that individual issued certificates belong to edubase_get_exam_certificates_user and that preset configuration comes from edubase_get_quiz_grading_presets. An agent can immediately identify what this tool returns.

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

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

The description gives clear usage context: certificates depend on a grading preset that determines success, the returned shape differs depending on whether certificates are enabled, and individual result certificates are handled by edubase_get_exam_certificates_user. It does not explicitly list when-not-to-use scenarios, but the sibling routing and prerequisite reference are strong 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, idempotentHint, and destructiveHint=false. The description adds useful behavioral context by specifying the three categories of presets returned (public, owned, user's organization presets), which tells the agent what scope to expect from the response.

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

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

Two sentences with no filler; the action and scope are front-loaded. Every clause adds information and nothing is redundant.

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

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

For a simple read-only list operation with an output schema and fully documented optional parameters, the description is sufficient. It covers purpose and result scope, and relies on the schema for parameter 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?

Both parameters are fully documented in the schema (100% coverage), so the baseline is 3. The description itself adds no param-specific detail beyond what the schema provides for 'exam' and 'language'.

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 ('List') and a specific resource ('certificate presets' for exams), and clarifies the returned scope (public, owned, user's organizations). The noun phrase 'certificate presets' differentiates it from sibling tool edubase_get_exam_certificates, which deals with actual certificates rather than presets.

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 retrieving exam certificate presets but does not explicitly state when to use it instead of alternatives, nor mention exclusions. There is no sibling tool with the same resource, so ambiguity is low, but explicit guidance is absent.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint: false, covering the safety profile. The description adds only the 'latest' behavioral nuance; it does not describe not-found behavior or what 'certificate details' contains, but the output schema helps fill that gap.

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

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

The description is a single sentence with no filler. The verb and resource are front-loaded, and the parenthetical 'latest' adds meaningful nuance without bloating the text.

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

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

For a simple read operation with complete parameter schemas, an output schema, and safety-related annotations, the description is nearly sufficient. The only notable omission is an explicit pointer to sibling tools for other certificate operations, but the 'specific exam and user' wording makes the intended use 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 both 'exam' and 'user' are already documented as identification strings. The description simply restates that they identify the exam and user, adding no extra semantic detail beyond the schema.

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

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

The description clearly states the operation ('get certificate details'), the scope ('for a specific exam and user'), and adds the nuance 'latest'. It is easily distinguishable from siblings like edubase_get_exam_certificates (which appears to be the collection-level variant) and edubase_post_exam_certificates_user_download (a download action).

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

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

The description implies when to use it: when you need the latest certificate details for one particular exam/user. However, it does not explicitly tell the agent to prefer other tools for retrieving all certificates or downloading certificates, leaving some sibling discrimination 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by specifying exactly which fields are included and when they are captured ('before they start their test'), which goes beyond the structured annotations.

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

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

The description is two sentences with no filler. The primary action and resource are front-loaded, and the clarifying detail about built-in versus custom fields 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 getter with one well-documented parameter, an output schema, and safety annotations, the description covers what the tool returns and the resource scope. Nothing an agent needs to call it correctly is missing.

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

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

The schema already provides a 100% description of the single 'exam' parameter as 'exam identification string'. The description adds no parameter-level detail, but because schema coverage is complete, 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 tool retrieves user data fields for an exam and enumerates what those are: built-in name/email/phone fields plus custom fields. This distinguishes it from siblings like edubase_post_exam_fields and edubase_delete_exam_fields, which perform different actions on the same resource.

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 — fetching the field definitions examinees encounter — but does not explicitly state when to prefer it over alternatives or mention that modifications are handled by sibling tools. An agent can infer the purpose but receives no direct guidance about exclusions or related tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description adds useful behavioral context: it returns all user answers, is not meant for display, and may require extra permissions. This goes beyond the schema without contradicting 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 compact and front-loaded with the core purpose, followed by the most important usage caveats. Every sentence adds actionable information without unnecessary verbosity.

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 read-only tool with an output schema, the description covers the decision-relevant facts: rawness of the data, inclusion of all answers, non-display intent, and permission requirements. Nothing essential is missing for an agent to decide whether to call this tool.

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

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

The input schema has full description coverage for the single 'exam' parameter, so the parameter meaning is already available. The description reinforces that the tool targets a specific exam but adds no new parameter-level detail beyond the schema.

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

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

The description clearly identifies the operation as getting raw results for a specific exam, and adds the key distinguishing detail that it returns all answers given by the user. This separates it from related result-returning sibling tools like edubase_get_exam_results_user.

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

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

The description provides explicit usage context: use only when very detailed results are needed, do not display the output to users, and be aware that additional permissions may be required. It stops short of naming an alternative result endpoint, but the guidance is clear enough.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context by enumerating exactly what fields the results include (times, points, attempt index, validity, pass status), which helps the agent anticipate the response. It does not mention rate limits or auth, but the annotation coverage lowers the bar.

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

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

Two sentences, no filler. The main function is front-loaded, and the sibling routing is a separate, clearly marked sentence. Every sentence earns its place.

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

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

For a simple, read-only listing tool with two required parameters and an output schema present, the description is complete. It states what the tool returns and how to get more granular data, so an agent has enough context to invoke it correctly. No critical information is missing.

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

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

Schema coverage is 100% with both parameters described as 'identification string,' so the schema already defines the parameters. The description only confirms that 'exam' and 'user' are the identifiers in the context of the tool, adding no format, type, or usage details beyond what the schema provides. Baseline 3 applies.

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

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

The description starts with a specific verb ('List') and identifies the exact resource ('results (attempts) of a user in an exam') along with the data elements included ('times, points, attempt index, validity and whether they passed'). It also distinguishes itself from the sibling edubase_get_quiz_results_play by noting that sibling covers per-question details, making the purpose unambiguous.

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

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

The second sentence gives explicit guidance: 'Use edubase_get_quiz_results_play for the per-question details of an attempt.' This tells the agent exactly which sibling to use when deeper detail is needed and implies this tool is for summary-level results. Clear and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering safety. The description adds value by specifying the exact fields returned, which enriches the behavioral context without contradicting annotations. No side effects are mentioned but none are expected for a read operation.

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

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

Two concise sentences: the first states purpose and returns, the second points to the complementary sibling. No filler words, and the core purpose is front-loaded.

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

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

With an output schema available, the return structure is documented externally. The description covers the purpose, the key data points, and the related mutation tool. It is complete for a simple getter, though it could briefly mention that the exam parameter refers to an existing exam ID.

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

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

The schema provides 100% coverage for the single 'exam' parameter with a description of 'exam identification string'. The tool description adds no further details about the parameter's format or how to obtain it, so it relies entirely on the schema. Baseline 3 is appropriate.

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

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

The description explicitly states the action ('Get the current round of an exam') and enumerates the exact data returned (index, start time, results presence, frozen state). It also names the sibling tool for creating a new round, clearly distinguishing its purpose from edubase_post_exam_round.

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

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

It implies when to use this tool (when you need the current round's status) and explicitly directs to edubase_post_exam_round for starting a new round. However, it does not contrast with other read-only exam tools like edubase_get_exam or edubase_get_exam_status, so some context on alternatives is missing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so no contradiction exists. The description adds useful domain context about the exam hierarchy but does not disclose additional behavioral traits such as pagination behavior, ordering, or what the response contains. Given the annotations cover the safety profile, a mid-range score is appropriate.

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 wasted words. The primary action is front-loaded ('List owned and managed exams'), and the second sentence provides relevant domain context without redundancy.

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

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

For a simple read-only list endpoint, the description combined with the fully documented input schema, annotations, and presence of an output schema is sufficient. Nothing critical is missing for an agent to select and call 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%, so the schema already documents all four parameters (page, limit, active, search) clearly. The description adds no additional parameter semantics beyond the schema, placing it at the baseline for fully documented schemas.

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'), a resource ('owned and managed exams'), and differentiates from singular operations like edubase_get_exam by clearly indicating a plural list scope. The additional hierarchical context ('highest level in the EduBase Quiz hierarchy, built from Quiz sets') further clarifies what an exam is relative to other resources.

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

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

The description states the tool's purpose but does not explicitly say when to prefer this over alternatives such as edubase_get_exam (for a single exam) or edubase_get_quizes (for quiz sets). The intended use is implied rather than explicitly contrasted with sibling 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 mark the tool read-only, idempotent, and non-destructive. The description adds meaningful behavioral nuance: surveys are never graded, grading/results viewing settings are omitted for them, and results export columns cannot be configured for surveys. This goes beyond the annotations without contradicting them.

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

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

The description is terse and well-structured: the core purpose is stated first, followed by relevant edge-case behavior for surveys. Every sentence contributes useful information without redundancy or filler.

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

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

This is a low-complexity, single-parameter read-only tool with a rich output schema and annotations covering safety. The description clearly explains the main behavior and important survey-specific exclusions, so an agent has sufficient context to invoke it correctly.

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

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

The only parameter, 'exam', is fully described in the schema as 'exam identification string', so schema description coverage is 100%. The description does not add additional meaning about the parameter's format, domain, or constraints, which is acceptable because the schema already covers it.

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

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

The description opens with the verb and resource explicitly: 'Get the settings of an exam.' The tool name and title reinforce this, and the survey-specific caveats show it is about retrieving settings rather than mutating them. It is clearly distinguishable from mutation siblings like edubase_patch_exam_settings.

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

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

The description implies usage is for retrieving exam settings but does not explicitly state when to use this tool instead of alternatives or name any sibling for comparison. The survey caveats provide useful context but do not give when/when-not guidance relative to other available 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the behavioral nuance that skills are retrieved indirectly through the exam's quiz set, which is useful context beyond the annotations. 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 description is a single, well-structured sentence that begins with the action verb and directly states the resource and returned fields. There is no redundant wording, and all content 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 tool with one parameter and an output schema, the description adequately covers what the tool does and what it returns. Minor gaps, such as behavior when the exam has no quiz set, are not critical for an agent to invoke it correctly. The existence of an output schema relieves the description of explaining return structure.

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

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

The schema description for the 'exam' parameter is 100% covered ('exam identification string'). The tool description does not add additional meaning about the parameter beyond what the schema provides; it merely reflects the same identification role. Baseline 3 is appropriate given the 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 states a specific verb ('Get'), a precise resource ('skills defined in the Quiz set used by an exam'), and enumerates the returned fields (identifier, title, description). It clearly distinguishes itself from the sibling tool edubase_get_quiz_skills by specifying the indirection through an exam.

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

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

The description provides clear context: this tool retrieves skills from the quiz set associated with an exam, implying it is the correct choice when the entry point is an exam rather than a quiz. However, it does not explicitly mention alternatives or exclusion criteria, so it stops short of a full usage guide.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the specific behavior of returning a status that indicates whether new tests can start, which is useful context beyond the annotations. It does not contradict any 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, well-structured sentence that leads with the verb and includes the key outcome. There is no wasted wording, and it is appropriately concise for a simple 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 simple read-only tool with one parameter and an output schema present, the description is sufficient to guide an agent. It states the purpose and the specific information returned. The output schema handles return details, and annotations cover safety. The only minor gap is lack of explicit error-case behavior, but that is not critical here.

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% coverage for the single 'exam' parameter with the description 'exam identification string'. The tool description adds no additional meaning or format details beyond that. Since the schema fully documents the parameter, 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 states a specific verb ('Get'), resource ('status of an exam'), and the key semantic ('showing whether new tests can be started'). This clearly distinguishes it from siblings like edubase_get_exam (which likely retrieves full exam details) and edubase_post_exam_status (which modifies status).

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

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

The description implies the usage case: checking if new tests can be started. However, it does not explicitly mention alternatives or exclusions, such as 'use this instead of edubase_get_exam' or 'do not use if you need the full exam details'. Given the large set of exam-related siblings, explicit differentiation would help, but the implied usage is reasonably 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the output includes user names and routes mutation needs to the post endpoint, which is useful behavioral context beyond the annotations.

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

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

Two concise sentences with no filler. The core purpose is stated first, and the second sentence efficiently points to the complementary write tool without redundancy.

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

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

This is a simple read-only listing tool with one fully documented parameter, an output schema, and safety annotations. The description gives sufficient orientation, including the relationship to the assignment endpoint, so nothing essential is missing.

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

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

The single required parameter 'exam' has full schema coverage with a clear description ('exam identification string'). The tool description's phrase 'assigned to an exam' reinforces the parameter's role but does not add new format or constraint details, so 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 states a specific verb ('List') and resource ('users assigned to an exam'), and clarifies that names are included. It also implicitly distinguishes itself from sibling tools like edubase_post_exam_users by naming that tool for the assignment 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 explicitly points to edubase_post_exam_users for assigning users, which makes clear that this tool is for the read-only listing case. It provides useful context but does not spell out all exclusions or alternative read tools such as edubase_get_exam.

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?