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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description warns 'Changes stored DeepTutor learning data' and instructs to 'Check the target ID and values.' It also discloses the consequence of not supplying a summary (a potential DeepTutor model call). These are meaningful behavioral traits not present in 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 three sentences, ordered as warning, purpose, and requirement. Each sentence adds distinct value: the warning alerts to side effects, the purpose is clear, and the summary requirement prevents an unintended model call. It could be tightened slightly, but it's efficient and front-loaded with the caution.

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

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

Given the tool's complexity (7 params, 6 required) and that an output schema exists, the description covers the key behavioral context: when to call (explicit learner request), what to verify (target ID/values), and a critical requirement (Codex-supplied summary). The schema handles parameter details, so this 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%, so the baseline is 3. The description adds marginal semantic value for parameters: 'Codex must supply summary' reiterates the schema's summary description, and 'Check the target ID and values' vaguely refers to notebook_id but doesn't add concrete format or selection guidance beyond the schema.

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

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

The description states the action with a specific verb and resource: 'Save a Codex-produced lesson or note in a DeepTutor notebook.' This clearly identifies an add operation, and the sibling names (update_notebook_record, delete_notebook_record) make the purpose distinct enough, though the description itself doesn't explicitly contrast with 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 gives an explicit when-condition: 'call only when the learner explicitly requests this action.' It also adds a prerequisite: 'Codex must supply summary to avoid a DeepTutor model call.' It doesn't mention alternatives like update or delete, but the 'only when' clause provides clear gatekeeping.

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 warns that the tool changes stored DeepTutor learning data and emphasizes user authorization, which adds important behavioral context beyond the annotations' readOnlyHint=false and destructiveHint=false. It does not explain side effects like duplicates or idempotency, but the core mutation risk is clearly disclosed.

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

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

The description is concise and front-loaded with the critical warning before stating the purpose. It could be slightly more streamlined, but there is no filler and the important caution earns its place.

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

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

With an output schema present and all parameters documented in the input schema, the description provides adequate context for calling the tool: purpose, mutation warning, and explicit authorization condition. It does not elaborate on optional parameters like label or source_anchor, but those are already defined in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add significant per-parameter meaning beyond what the schema already states, although 'Check the target ID and values' generally reinforces the need to validate material_id, locator, and confirm.

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

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

The description states a clear action and resource: 'Bookmark a unit in a reading material.' It does not explicitly contrast itself with sibling tools like list_reading_bookmarks or delete_reading_bookmark, but the verb and target are specific enough for an agent to identify the operation.

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

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

The description gives actionable guidance: call only when the learner explicitly requests the action, and require checking the target ID and values before invoking. It does not mention alternative tools for when not to use it, but it gives clear contextual prerequisites for a write operation.

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

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

The description goes beyond annotations by warning 'Changes stored DeepTutor learning data' and requiring explicit learner request. Annotations already indicate readOnlyHint=false, so the mutation claim is consistent. It adds a caution about verification that is not present in structured fields.

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

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

The description is concise, with the critical warning front-loaded. It consists of one sentence plus a warning prefix, conveying purpose and condition efficiently. No redundant filler, though the warning is slightly verbose but justified.

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

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

Given the tool's complexity (5 params, 4 required, output schema present, 100% coverage), the description covers the action, the condition for use, and a verification caution. It does not explain return values, but an output schema exists to handle that. The essential knowledge for a correct call 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?

Schema description coverage is 100%, so all parameters are documented. The description adds a general warning to check values, but does not introduce specific parameter semantics beyond the schema. It hints that ref_id is an existing resource, but the schema already states that. 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 the verb 'attach' and the resource ('existing book, knowledge base, notebook or other supported resource') to a course. It is distinct from siblings like replace_course_syllabus or list_course_resource_candidates, though it does not explicitly name a sibling. The action is unambiguous.

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

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

The description gives explicit guidance: 'call only when the learner explicitly requests this action.' It also instructs to check the target ID and values, which serves as a safety check before invoking. It does not mention alternatives, but the condition for use is clear and relevant.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the key behavioral trait that no review is recorded, which goes beyond the annotations and helps the agent understand the side-effect-free nature of this 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?

A single, front-loaded sentence that conveys the core purpose and key distinction with zero filler. Every word earns its place.

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

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

For a simple two-parameter tool with an output schema, the description sufficiently covers what the tool does and its non-recording behavior. It does not explain what 'check' means in terms of return values, but the output schema likely handles that. No critical information is missing for calling the tool correctly.

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

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

Schema description coverage is 100% for both parameters (entry_id and answer), so the schema already documents their meaning. The description adds no additional parameter-level context, 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 the action ('Check an answer') and the resource ('answer'), and the qualifier 'without recording a review' distinguishes it from the sibling tool record_practice_review. An agent can immediately understand what this tool does and what it does not do.

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

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

The phrase 'without recording a review' implies this tool is for checking when no review recording is desired, contrasting with record_practice_review. However, it does not explicitly name the alternative tool or provide a when-to-use/when-not-to-use rule, 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 explicitly states that this tool modifies stored DeepTutor learning data and includes a warning to check the target ID and values. The annotations indicate readOnlyHint=false and destructiveHint=false, which do not specify safety, but the description compensates by highlighting the write operation. It also emphasizes user authorization, which is a behavioral trait beyond annotations. Credit for adding this context.

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

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

The description is compact, with a prominent warning at the front. It's two sentences, with the warning leading the purpose. No redundant words. It earns a 4 because it's focused and front-loaded, though it could be more specific about the notebook's purpose.

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

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

The description includes a safety warning about authorization, which is essential for a write operation. The output schema exists, so return values are covered. Parameters are fully documented in the schema. The description is concise and covers the key usage context. It misses a bit on defining what a notebook is, but overall sufficient.

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

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

The input schema has 100% description coverage for all 5 parameters, including descriptions for 'name', 'icon', 'color', 'confirm', and 'description'. The description adds value for the 'confirm' parameter by explaining it's for write authorization, which is crucial for the agent. Since the schema already covers parameter names, the extra context on 'confirm' is a bonus.

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 'Create a DeepTutor notebook' which identifies the verb and resource, but it's vague about what 'notebook' means in this context. It doesn't distinguish from similar tools like 'add_notebook_record' or 'delete_notebook' beyond the obvious. The function is a write operation, but without more context, an agent may not know exactly what creating a notebook entails.

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

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

The description includes a strong warning: 'call only when the learner explicitly requests this action', which provides clear usage guidance. However, it doesn't mention any alternatives or when not to use this tool (e.g., when updating an existing notebook, use update_notebook_record). The warning is useful but limited.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description is consistent with the safe, non-destructive nature of the operation. It adds minimal context beyond the annotations by specifying that it checks the 'configured' backend and API availability, but it does not describe error behavior or what 'availability' entails.

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 conveys the full purpose without redundant words or filler. It is appropriately minimal for a simple status-check tool.

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

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

Given the zero-parameter input schema, the presence of an output schema, and annotations covering the safety profile, the description is complete. An agent has enough information to select and invoke this tool correctly without additional context.

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

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

The input schema has zero parameters, so there is nothing the description needs to explain about parameters. The baseline of 4 applies because no parameter documentation is required.

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 ('Check') and a clear resource ('configured DeepTutor backend and API availability'). It clearly distinguishes itself from sibling tools, which operate on sessions, messages, or content rather than reporting overall backend health.

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

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

The description implies the tool is used to verify backend readiness before or during DeepTutor operations, but it does not explicitly state when to use it or mention any alternative tools. The usage context is inferred from the purpose rather than stated directly.

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

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

The annotations declare destructiveHint: false, but the description explicitly warns that it 'Changes stored DeepTutor learning data' and deletes an entire notebook, which is clearly destructive. This is a direct contradiction between the structured annotation and the description. Per rubric, any contradiction yields a score of 1.

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 sentences. The warning is front-loaded, immediately conveying the risk, followed by the clear action. Every word earns its place; no fluff or repetition.

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

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

The description covers the critical context for a destructive operation: it warns about data changes, instructs on when to call, and advises validation. An output schema is present, so return details are not needed. However, it does not explicitly state irreversibility or what happens after deletion, but the warning largely suffices. The main gap is the annotation contradiction, which is penalized elsewhere.

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

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

The input schema already documents both parameters (notebook_id and confirm) with full coverage. The description adds a caution to 'Check the target ID and values', which reinforces the importance of the confirm flag, but does not introduce new parameter meaning beyond what the schema provides. Baseline 3 applies 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 clearly states the verb and resource: 'Delete an entire notebook'. It distinguishes from siblings like delete_notebook_record (deletes a record within a notebook) and delete_reading_annotation, making the scope unambiguous. The warning also clarifies it is a whole-notebook 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 instructs to 'call only when the learner explicitly requests this action', which provides a clear condition for use. It does not name alternatives, but the scope (entire notebook) implicitly differentiates it from record-level deletion tools. It also advises checking the target ID and values, reinforcing careful 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?

The description states 'Changes stored DeepTutor learning data' and 'Delete a notebook record', which clearly indicates a destructive write operation. However, the annotation destructiveHint is false, directly contradicting the description. This is a serious inconsistency, so the description fails to provide transparent behavioral information that aligns with annotations.

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

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

The description is concise, consisting of a warning and a short statement. The warning is front-loaded, which is helpful. It avoids redundancy and is structured logically, though the warning could be considered slightly verbose given the annotation contradiction.

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 deletion operation with an output schema and full parameter documentation. However, the description fails to resolve the contradiction between its destructive warning and the destructiveHint annotation, leaving the agent uncertain about the tool's actual behavior. It also does not clarify prerequisites or expected outcomes beyond the schema, making it incomplete for safe invocation.

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

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

The schema already provides full descriptions for all three parameters (notebook_id, record_id, confirm), and schema coverage is 100%. The description adds no new parameter-level details, only generic advice to 'check the target ID and values'. With high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action: 'Delete a notebook record'. It names the specific verb and resource, and it is distinct from siblings like update_notebook_record or delete_notebook. The warning about changing learning data reinforces the destructive nature without obscuring the core purpose.

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

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

The description provides a usage condition: 'call only when the learner explicitly requests this action'. It also advises to check the target ID and values. However, it does not mention alternatives or explicitly state when not to use this tool vs. other notebook-related tools, 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description adds value beyond them by warning that this changes stored DeepTutor learning data and by requiring explicit learner authorization. This is useful safety context and 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 concise and contains no filler. The warning is intentionally front-loaded for a destructive action, and the core purpose is stated clearly at the end. The structure is slightly unusual in placing the action last, but it remains efficient and readable.

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

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

The tool is simple with two scalar parameters and an output schema, so return values do not need description coverage. The annotations cover the safety profile, and the description adds the key authorization precondition. It is complete enough for an agent to 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 entry_id and confirm are already fully documented in the schema. The description's 'Check the target ID and values' loosely maps to those parameters but does not add format, constraints, or semantics 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 states a specific verb and resource: 'Delete one Question Bank entry.' This clearly distinguishes it from sibling tools like get_question_entry, update_question_entry, and upsert_question_entry by the destructive action. The warning reinforces that this is a deletion, not a read or update.

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

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

The description provides an explicit precondition and when-not condition: 'call only when the learner explicitly requests this action.' It also tells the agent to check the target ID and values before proceeding. It does not name a specific alternative tool, but the guidance is clear enough for a destructive operation.

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 warns 'Changes stored DeepTutor learning data', which is an accurate behavioral disclosure for a delete operation. However, the annotation destructiveHint is set to false, directly contradicting the notion that this tool modifies stored data. This contradiction is a serious inconsistency: the agent cannot trust the annotation, and the description's warning conflicts with the structured metadata. Per the rubric, a contradiction yields a score of 1.

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 fluff. The warning is front-loaded, immediately signaling importance, and the action statement follows. Every word earns its place. It is concise while conveying the critical usage warning.

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 tool with an output schema, the description covers the essential context: it warns about data changes and the explicit-request requirement. It does not discuss error handling or idempotency, but those are minor given the straightforward action and the presence of an output schema. However, the annotation contradiction reduces the overall completeness, as structured metadata is unreliable.

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 (material_id, annotation_id, confirm) is already described in the schema, including the confirm boolean's purpose ('Set true when this write is authorized by the current user request'). The description does not add any new semantic information beyond the schema, 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 the action: 'Delete one reading annotation' – a specific verb and resource. It distinguishes from siblings like save_reading_annotation and list_reading_annotations by explicitly saying 'delete' and 'one reading annotation'. The warning at the start reinforces the specific nature of the operation.

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

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

The description explicitly states when to call: 'call only when the learner explicitly requests this action'. This is a strong usage condition. It also advises to 'Check the target ID and values', which guides the agent on pre-call verification. Although it does not name an alternative, the condition is unambiguous and sufficient for an agent to decide when to invoke the tool.

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

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

The description says the tool deletes a reading bookmark and changes stored DeepTutor learning data, which implies a destructive write. However, annotations declare destructiveHint: false, contradicting the deletion behavior. Per the rubric, this is an annotation contradiction.

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

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

The description is short and front-loads the important warning before stating the action. It is efficient, though the warning and the actual purpose are somewhat split across multiple clauses.

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 safety warning and authorization condition are useful, and an output schema exists. However, the contradictory destructiveHint annotation undermines completeness, and the description does not clarify irreversibility or what specific learning data changes occur.

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 has a description, including the confirm flag. The description adds only a generic reminder to check target IDs and values, which does not meaningfully exceed the schema's 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: 'Delete one reading bookmark.' This clearly distinguishes it from sibling tools like add_reading_bookmark, list_reading_bookmarks, and delete_reading_annotation.

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

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

The description explicitly says to call only when the learner explicitly requests the action and to check the target ID and values first. It provides a clear when-to-use condition, though it does not mention alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only behavior is established. The description adds useful context about the returned content, specifically source links and blocks, which goes 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, well-structured sentence that leads with the core action and resource, then adds the most relevant content detail. No unnecessary words or repetition.

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

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

This is a simple read-only getter with two clearly documented parameters and an output schema. The annotations cover the safety profile, and the description names the key content areas, making it complete for an agent to select and invoke 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, documenting both book_id and page_id. The description adds no additional parameter meaning beyond the 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 states a specific verb ('Read') and resource ('a generated book page'), and adds content details ('including source links and blocks'). This clearly distinguishes it from siblings like get_book_spine and list_books, which cover different aspects of book content.

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

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

The description explains what the tool does but gives no guidance on when to use it versus alternatives such as get_book_spine or get_reading_unit. No exclusions or routing hints are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' is consistent with that. The description does not add behavioral context beyond the object being read, but no extra caveats are necessary for a simple read-only lookup.

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 six-word sentence with no filler; the action, resource, and result object are all present. It is optimally front-loaded and easy to scan.

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

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

For a one-parameter, read-only tool with an output schema and read-only annotations, the description is largely sufficient to support correct invocation. However, it is terse enough that an agent receives no context about what a 'spine' contains or how this relates to book pages, leaving a small gap in completeness.

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

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

The only parameter, book_id, is fully described in the schema with type and a short description, so schema coverage is 100%. The description adds no parameter-level detail, but none is needed beyond identifying the book.

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 concrete verb ('Read') and a precise object ('a book's chapter and page structure'), making clear it returns structural metadata rather than page content. This distinguishes it from sibling tools like get_book_page, which reads a single page's content.

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

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

No explicit when-to-use or when-not-to-use guidance is given; there is no mention of alternatives such as get_book_page or list_books. The intended use is only implied by the phrase 'chapter and page structure,' so the agent must infer when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description reinforces this with 'Read' and adds specific context by enumerating the components (syllabus, resources, sessions, mastery, question statistics), which gives the agent a clearer picture of what data will be accessed. It does not disclose any unexpected behaviors and is fully consistent with the read-only 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 concise sentence, front-loaded with the verb 'Read' and the scope 'one course'. It lists the data categories without unnecessary words, making it efficient and easy to parse. Every part of the sentence contributes meaning, and there is no fluff.

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

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

Given the tool's simplicity (one parameter) and the presence of an output schema, the description is sufficient for an agent to understand the tool's purpose and what it returns. It enumerates the data categories, which is helpful. It does not mention error conditions or prerequisites, but for a read-only tool with a single parameter, these are minor gaps.

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

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

The only parameter course_id has a schema description 'Course ID' which provides 100% coverage of its meaning. The description does not add any additional semantic detail about the parameter, such as format, source, or constraints. Since the schema already documents the parameter adequately, the description adds no extra value here.

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

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

The description states a specific verb 'Read' and a specific resource: 'one course's syllabus, resources, sessions, mastery and question statistics'. It clearly identifies the scope (one course) and the components, making the tool's purpose evident. However, it does not explicitly differentiate from sibling tools like learning_overview or get_mastery_path, which might also read course-related data, so it stops short of full clarity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or comparisons with sibling tools. An agent has no information about when to prefer this over get_course_syllabus, learning_overview, or other read tools, leaving usage entirely to inference.

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

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

Annotations already mark this as readOnly and non-destructive, so the description's extra warning 'do not treat it as verified mastery' adds important behavioral context about data reliability that annotations do not convey. It also clarifies that the document is DeepTutor-generated, which implies it may need scrutiny. No contradiction with annotations.

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

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

The entire description is one short sentence with no filler, and the key behavioral caveat is placed after the core action, keeping the most important information 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 tool is a simple getter with a full output schema and two fully documented parameters; the description covers its purpose and the critical reliability caveat. Nothing an agent needs to invoke it correctly is missing given the structured fields.

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; both 'key' and 'layer' are already fully described in the schema. The description only refers to L2/L3, which mirrors the enum, without adding new parameter semantics.

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

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

The description uses the specific verb 'Read' and names a precise resource: 'DeepTutor-generated L2 or L3 memory document.' The appended caveat 'do not treat it as verified mastery' distinguishes it from the many mastery-related sibling tools, so an agent can select it correctly.

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 about what the tool is for and sets the expectation that its content is not verified mastery, which is important for when to trust it. However, it does not explicitly name an alternative tool or state when to use it instead, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful caveat that content should be treated as historical data, but it does not describe what happens for missing or invalid session IDs or any other runtime behavior.

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

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

A single sentence that front-loads the core action ('Read') and the resource type. Every word contributes, and the historical-data note adds meaningful 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 getter with one parameter, annotations, and an output schema, the description is sufficiently complete. It could name the related listing tool for discovering session IDs, but that 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?

Schema description coverage is 100%, with the single session_id parameter already described as 'Session ID'. The description adds no additional meaning about how to obtain or format the session ID, so it does not go beyond the schema.

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

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

The description uses a specific verb ('Read') and resource ('one prior DeepTutor conversation record'), making the operation clear. The phrase 'historical data' distinguishes it from interactive or mutating DeepTutor tools like send_message_to_deeptutor.

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 past conversation records and treating them as historical, but it does not explicitly state when to use it over list_deeptutor_sessions or send_message_to_deeptutor. The guidance is reasonable but leaves alternatives to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to re-establish the safety profile. It adds the conceptual read scope ('evidence, mastery and review state') but does not disclose further behavioral details such as pagination, auth requirements, or response semantics.

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

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

The description is a single, front-loaded sentence that states the verb, object, and scope with no filler. Every word contributes to the agent's understanding of what the tool reads.

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 an output schema and read-only annotations, the description provides enough context for correct invocation. The required parameters are fully specified, and the read scope is explicit, so no material details are missing.

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

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

The schema already documents both parameters with 100% coverage, so the description is not burdened with explaining path_id or knowledge_point_id. It adds no additional parameter-level meaning beyond what the schema provides, making the baseline score of 3 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 the specific verb 'Read' and identifies the exact resource: one knowledge point's evidence, mastery, and review state. This clearly distinguishes it from sibling getters like get_mastery_path or get_mastery_review_settings, which target different resources or 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 phrase 'one knowledge point's evidence, mastery and review state' gives clear context for when this tool is appropriate: retrieving per-knowledge-point mastery data. However, it does not explicitly name alternatives or state when not to use it, so it lacks full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by enumerating what is included in the read (outline, revision, reviews), giving the agent a concrete expectation of the response content. This goes beyond the minimalist annotation coverage and clarifies the tool's operational scope.

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

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

A single, well-structured sentence with zero fluff. The core action and resource are placed at the start, and the optional content qualifiers ('including outline, revision and reviews') follow naturally. Every word earns its place.

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

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

For a simple read tool with one clearly documented parameter and a read-only annotation pair, the description is nearly complete. The output schema exists and is expected to describe return values, so the description does not need to explain them. It could arguably mention error behavior (e.g., not found), but that is not essential for correct invocation.

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

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

Schema description coverage is 100%; the parameter 'path_id' is already documented as 'Mastery path ID' in the schema. The description adds no additional meaning or format constraints beyond what the schema provides. Per the rubric, baseline 3 is appropriate when the schema carries the full semantic load.

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 verb ('Read'), a specific resource ('Mastery Path'), and specifies the scope ('including outline, revision and reviews'). This distinguishes it from sibling tools like list_mastery_paths (which lists paths) and get_mastery_objective (which targets objectives). No ambiguity remains about what the tool retrieves.

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

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

The description implies usage: when you need a single mastery path's details, use this. However, it does not explicitly reference alternatives or exclusions, such as 'use list_mastery_paths to enumerate paths' or 'use get_mastery_objective for objectives'. The context is understandable but not maximally instructive for distinguishing among close 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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the specific term 'desired retention' but discloses no additional behavior such as error handling, authentication, or pagination. Since the tool is a simple read, the annotation coverage plus minimal specificity yields a mid-range score.

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 extraneous words. It efficiently communicates the core purpose, which is ideal for a simple read 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 tool with one parameter and an existing output schema, the description covers the essential purpose. It could clarify what 'desired retention' means or indicate what the response contains, but the output schema presumably handles return details. The description is sufficient 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?

Schema coverage is 100% with path_id described as 'Mastery path ID'. The description does not add any further meaning to the parameter, such as format, examples, or constraints. The baseline of 3 applies because the schema fully documents the parameter.

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

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

The description states a specific verb ('Read') and a clear resource ('a path's desired retention'), which aligns with the tool name. It distinguishes from write tools like set_mastery_review_settings but doesn't explicitly contrast with other read tools like get_mastery_path, leaving slight ambiguity about its unique 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?

No guidance is given on when to use this tool versus alternatives. It doesn't mention prerequisites, when to prefer it over get_mastery_path or other getters, or any context such as requiring an existing path. The agent must infer usage from 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 provide readOnlyHint=true and destructiveHint=false, so the description doesn't need to state safety. It adds that the tool returns 'saved records', giving a bit more detail about the output, but doesn't disclose potential limitations like pagination or size constraints. This is minor added value beyond annotations.

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

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

The description is a single, front-loaded sentence that directly communicates the action and object. It contains no unnecessary words and is perfectly concise.

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

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

For a simple getter with one parameter, read-only annotations, and an output schema, the description is nearly complete. It clarifies that saved records are included, which is a key detail. Minor gaps like pagination are not critical given the 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% with a description for notebook_id, so the schema already documents the parameter. The description adds no extra meaning about the parameter, such as format or how to obtain it. 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 'Read a notebook and its saved records' uses a specific verb and resource, clearly indicating a read operation on a notebook. It distinguishes from sibling tools like create_notebook, delete_notebook, and list_notebooks, 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?

Usage is implied by the description and the parameter schema: you need a notebook_id to read a specific notebook. However, there is no explicit guidance on when to use this tool vs alternatives like list_notebooks or get_book_spine, and no mention of when not to use it.

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

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

The description is a read operation, consistent with annotations (readOnlyHint=true, destructiveHint=false), so no contradiction. However, it adds minimal behavioral context beyond the annotations: it mentions that it returns both a question and its review version, which is some useful detail. But it doesn't describe any limits, pagination, or content structure. Since the annotations already cover the safety profile, a 3 is reasonable.

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

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

The description is a single, short sentence with no filler. It is front-loaded with the action and resource, though it could be more informative without adding much length. It wastes no words, so it earns a 4.

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

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

The tool has a simple interface (1 param, output schema present) and annotations cover safety. The description is minimal but perhaps adequate for a straightforward read operation. However, it does not explain the concept of 'review version' or how the output might differ from a normal practice question, which could be important for correct invocation. Given the presence of an output schema, the return value is likely documented there, so the description does not need to explain that. Overall, it is barely sufficient, so a 3.

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 single parameter 'entry_id' as a string. The description does not add any extra detail about the parameter (e.g., format, source, or required context). With 100% coverage, the baseline is 3, and the description does not exceed that.

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

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

The description states a clear verb ('Read') and resource ('practice question') and mentions it also returns a 'review version'. This is specific enough to understand the basic purpose, but it does not differentiate from siblings like 'check_practice_answer' or 'record_practice_review' which also deal with practice questions. The distinction is not explicit.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of what the 'review version' is for or when an agent should prefer this over 'check_practice_answer' or 'record_practice_review'. The description leaves the usage context entirely implicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description merely repeats the read-only nature. It adds no extra behavioral context such as error behavior, missing-entry handling, or authorization requirements.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the operation and resource, which is appropriate for such a simple read 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 one-parameter read-only tool with annotations and an output schema, the description is nearly complete. It could be improved by explicitly noting when to prefer list_question_entries, but the current information is otherwise sufficient for correct invocation.

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

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

Schema coverage is 100%, so the schema already provides adequate meaning for the only parameter, entry_id. The description does not add additional detail beyond the schema, but given the high 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 states a specific action ('Read') and a specific resource ('one native Question Bank entry'). It clearly distinguishes this singleton lookup from list_question_entries and the mutation tools like upsert/update/delete_question_entry.

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

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

There is no explicit guidance about when to use this tool versus alternatives. It does not mention that list_question_entries should be used for fetching multiple entries, nor does it address edge cases like invalid IDs.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat that. It adds value by specifying what is read (outline, units, metadata), giving context about the return content. However, it does not disclose edge cases, potential errors, or any additional behavioral characteristics, so it is adequate but not rich.

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 with no redundancy. The verb 'Read' is front-loaded, and the resource and scope are immediately clear. Every word contributes meaning, making it an exemplar of concise description.

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

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

Given the tool's simplicity (one parameter, read-only, output schema present), the description fully covers what an agent needs to call it correctly. It does not need to explain return values because an output schema exists, and annotations cover the safety profile. 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?

Schema coverage is 100%—the parameter material_id is described as 'Reading material ID'. The description adds a slight implication that the material is a single entity, but it does not provide additional syntax or format details beyond the schema. With full 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?

The description clearly states the action ('Read') and the resource ('one material's outline, units and metadata'). It distinguishes from siblings like get_reading_unit (which focuses on a single unit) and list_reading_materials (which lists all), even if not explicitly naming them. The scope 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention conditions for use, prerequisites, or exclusions (e.g., 'for a specific unit use get_reading_unit'). The agent must infer usage from the description alone, which is insufficient.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context about boundedness and the single-unit scope, but it does not disclose behaviors such as offset handling, locator semantics, or limits beyond what the schema already states.

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

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

The description is a single front-loaded sentence with no wasted words. It conveys the essential operation and scope immediately, and every part of the sentence earns its place.

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

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

The full parameter descriptions, read-only annotations, and presence of an output schema cover most of what an agent needs to call the tool correctly. The main gap is the lack of explicit guidance about when to use this tool versus reading-material and book-page alternatives, but the structured metadata compensates well.

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 every parameter is already documented. The description adds no parameter-specific meaning beyond what the input schema provides, 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 ('Read'), a clear resource ('one reading unit'), and a scope qualifier ('bounded text slice'). It is distinct enough from likely siblings like get_reading_material, but it does not explicitly name or contrast any sibling.

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

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

The phrase 'bounded text slice' implies the tool is for reading a portion of a reading unit rather than the full material, so usage is inferable. However, it does not state when to prefer this over alternatives like get_reading_material or get_book_page, nor does it mention exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered. The description adds valuable behavioral context beyond annotations: it is a batched single-request read that does not consume a DeepTutor model turn, which informs cost and latency expectations.

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

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

A single front-loaded sentence conveys the resource scope, the aggregation behavior, and the key non-obvious trait (no DeepTutor model turn). Every word earns its place; there is no redundant or filler content.

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

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

Given an output schema exists, annotations cover safety, and there is only one optional parameter, the description is nearly complete for correct invocation. The only minor gap is not naming granular siblings like get_course_state, list_mastery_paths, or practice_queue as alternatives for deeper detail.

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

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

There is only one optional parameter and schema description coverage is 100%, so the schema fully documents 'timezone'. The description adds no parameter-specific details, which is acceptable because the schema carries the burden and the parameter has a clear default.

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 ('Read') and concrete resources ('courses, mastery summaries and due practice'), and the qualifier 'in one request; no DeepTutor model turn' clearly differentiates it from the many granular sibling tools. An agent can immediately recognize this as the aggregate read-only overview endpoint.

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

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

The phrase 'in one request' and 'no DeepTutor model turn' gives clear context: use this when a quick aggregate overview is needed without invoking model-based reasoning. It does not explicitly name alternatives or exclusion conditions, but the intended usage is inferable with high confidence.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the scope of 'from a book' and confirms the listing behavior, but does not mention optional filtering by status, ordering, or pagination; the existing output schema mitigates this.

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 redundant filler. Every word contributes to identifying the operation and its scope.

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

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

For a simple read-only list tool with a complete schema, read-only annotations, and an output schema, the description is nearly sufficient. The only notable gap is the lack of contrast with similar reading-related list tools, but that is more pertinent to usage guidance.

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 already documented. The description adds minimal meaning beyond the schema, only reinforcing the book_id scope through 'from a book'.

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: it lists saved learning captures scoped to a book. It is unambiguous on its own, though it does not explicitly differentiate itself from sibling tools like list_reading_annotations or list_reading_bookmarks.

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

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

No guidance is provided on when to use this tool versus alternatives such as list_reading_annotations or list_reading_bookmarks. There are no explicit conditions, exclusions, or references to 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 declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds that the tool returns 'status' of books, a small behavioral hint, but lacks details like pagination or scope. With annotations covering the main concerns, this is adequate but minimal.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the action and resource immediately, making it highly efficient.

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

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

Given the tool's simplicity (no parameters) and the existence of an output schema, the description is sufficient for an agent to call it correctly. It could mention scope (e.g., all books vs. current user) but that is not critical for a basic list operation.

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

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

The tool has zero parameters, so the schema fully covers everything. The baseline for zero parameters is 4, and the description does not need to add anything; it correctly omits parameter details.

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 ('generated learning books') with an added detail ('their status'), clearly distinguishing it from sibling list tools like list_courses and list_mastery_paths. It tells the agent exactly what to expect.

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. While the name is self-explanatory, there is no mention of exclusions, context, or when another listing tool might be more appropriate, leaving the agent to infer usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral traits beyond the obvious list operation, such as pagination, ordering, or whether returned resources are limited by course context.

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

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

The description is a single clear sentence with no filler or redundancy. It is appropriately front-loaded and every word contributes to 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?

Given zero parameters, an output schema, and safety annotations, the description is almost fully sufficient. The only minor gap is that 'resources' is somewhat generic and could be more precise about what kinds of attachable resources are included.

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

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

The tool has zero parameters, so the schema carries no parameter burden. The description does not need to explain parameter semantics, and the baseline of 4 applies because no additional parameter information is required.

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

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

The description uses a specific verb ('List') and resource ('resources that can be attached to a course'), making the core purpose clear. It semantically distinguishes itself from sibling tools like attach_course_resource, though it does not explicitly name or contrast any sibling.

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

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

The phrase 'that can be attached to a course' implies use in a course-resource attachment workflow, but the description gives no explicit when-to-use, when-not-to-use, or alternative-tool guidance. Usage is only suggested indirectly.

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

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

Annotations already signal a read-only, non-destructive operation. The description adds useful context that the result includes syllabus and linked resources, which goes beyond what the annotations state. No misleading or hidden behavior is disclosed.

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

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

The description is a single concise sentence that immediately states the action and scope. Every word contributes meaning, and there is no redundant or filler content.

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

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

For a parameterless read-only listing tool with an output schema, the description is largely adequate. The main gap is the lack of usage context relative to sibling tools, but this is a minor omission 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 tool has zero parameters, so the schema is complete and the description has no parameter burden. The baseline of 4 for parameter-free tools applies here.

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

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

The description names a specific verb ('List') and resource ('courses'), and adds scope by noting that syllabus and linked resources are included. It is clear but does not explicitly distinguish itself from related course-state tools like get_course_state or learning_overview.

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

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

No guidance is given about when to use list_courses versus sibling tools such as get_course_state or learning_overview. An agent is left to infer the appropriate context from the name alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description's 'informational' note reinforces this but does not add substantive behavioral context beyond what annotations provide. The 'unless' clause is more about usage than tool behavior. No contradiction; 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?

The entire description is a single, efficient sentence. It front-loads the core action ('List installed DeepTutor capabilities') and appends the usage qualifier. 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?

The tool has no parameters, has an output schema to describe return values, and annotations cover its safety profile. The description provides the essential purpose and a usage caveat, leaving no critical information missing for correct invocation. It is fully adequate for an agent to use this tool appropriately.

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

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

The tool has zero parameters, and the schema is empty with 100% coverage. Baseline for 0 params is 4. The description correctly avoids parameter details since there are none, so nothing is missing. No additional semantics 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 clearly states the verb and resource: 'List installed DeepTutor capabilities'. This is specific and distinct from other tools that deal with DeepTutor sessions or status, though it doesn't explicitly name a sibling. It conveys the primary purpose without 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 adds a usage nuance: 'informational unless the user directly requests a DeepTutor conversation'. This implies when to use it (informational requests) and hints it shouldn't be used for starting conversations, but it does not explicitly mention alternative tools or provide clear when-not-to-use scenarios. Guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds minimal behavioral context ('historical learning data') but does not mention pagination, ordering, or other runtime behavior beyond what the schema implies. 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 concise sentence, front-loaded with the verb and object. It avoids fluff, but could have included usage guidance without becoming verbose. It is effective though slightly under-specified for a tool with several siblings.

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 simple nature of the tool, the schema covers parameters and an output schema exists, so return format is not needed. However, the description lacks any indication of when to prefer this over related tools or details like the 'all_workspaces' behavior, which the schema describes but the description does not contextualize. Overall, it is minimally 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%, with clear descriptions for 'limit', 'offset', and 'all_workspaces'. The tool description adds no extra detail about parameters, so the baseline of 3 is appropriate given the schema already handles parameter documentation.

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

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

The description clearly states it lists 'DeepTutor conversation records' with the purpose of 'historical learning data'. The verb 'List' and the specific resource are unambiguous, and it is clearly distinct from sibling tools like 'get_deeptutor_session' which fetches a single session.

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

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

No guidance is given on when to use this tool versus alternatives such as 'get_deeptutor_session' or other listing tools. The description does not mention exclusions, conditions, or alternative selection criteria, leaving the agent to infer usage from the name alone.

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

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

Annotations already establish that this is read-only and non-destructive, so the description does not need to restate that. The phrase 'without exposing private configuration' adds a meaningful behavioral guarantee beyond the annotations, but the description does not disclose other behaviors such as output limits, ordering, or permission requirements.

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

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

The description is a single, front-loaded sentence with no filler. It immediately states the action and resource, then adds the privacy qualifier, making it easy for an agent to process 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 zero-parameter, read-only tool with an output schema and non-destructive annotations, the description is complete. It conveys the core purpose and the one important privacy caveat, and the surrounding structured data covers the remaining invocation contract.

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

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

The tool has zero parameters and an empty schema, so the parameter coverage is effectively complete. The baseline of 4 applies, and the description correctly avoids inventing parameter details that do not exist.

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

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

The verb 'List' and resource 'knowledge bases' are specific and clear, and the qualifier about not exposing private configuration adds useful scope. It does not explicitly distinguish itself from sibling tools like list_knowledge_files or read_knowledge_file, but the resource name is distinct enough to avoid major 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 gives no guidance on when to use this tool instead of the many sibling tools, such as list_knowledge_files or list_notebooks. There are no explicit alternatives, prerequisites, or exclusions, so an agent must infer the appropriate context 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=true and destructiveHint=false, so the safety profile is covered. The description adds a meaningful behavioral detail not in annotations: 'hides metadata files by default'. This informs the agent about default result filtering, which is valuable for predicting output. No contradiction with annotations.

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

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

The description is a single 11-word sentence that front-loads the core action and resource, then adds the key default behavior. No wasted words; every element earns its place.

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

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

With a complete input schema, an output schema, and annotations, the description's job is minimal. It successfully adds the crucial default-behavior context. The only gap is the lack of usage differentiation from search_knowledge_file, but that falls under usage guidelines and doesn't impede a correct call.

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 fully documents all six parameters. The description does not add any parameter-level meaning beyond what the schema already provides. Baseline 3 applies because the structured data carries the 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 states a specific verb and resource: 'Find document filenames in a knowledge base'. This clearly communicates the tool's function and distinguishes it from siblings like list_knowledge_bases (lists bases) and read_knowledge_file (reads content). It doesn't explicitly name alternatives, but the core purpose is unambiguous.

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

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

Usage is implied by the description: use this when you need to find document filenames. However, there is no explicit when-to-use vs alternatives, no exclusions, and no mention of search_knowledge_file as a content-search alternative. The guidance is functional but not explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description only needs to add context. It confirms a read-only operation and adds the revision-scope constraint, but does not disclose details such as event ordering, pagination, or whether the event list is sorted.

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 and gets the core resource and action across clearly. It is concise, though the phrase 'recorded changes' is slightly vague and could be more explicit.

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

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

An output schema exists and the annotations cover the safety profile, so the description is mostly sufficient for a simple read tool. A brief note on what counts as a 'revision' or how to find revision IDs would make it fully self-contained.

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 path_id and after_revision described in the input schema, so the baseline is 3. The description adds little beyond the schema, only the general idea of reading changes after a revision.

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

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

The description states a clear action ('Read') on a specific resource ('recorded changes to a Mastery Path') with a distinguishing scope ('after a revision'). This separates it from get_mastery_path and list_mastery_paths, which are the most likely sibling alternatives.

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

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

The phrase 'after a revision' implies this is the tool for retrieving Mastery Path change history, but it does not explicitly state when to use it versus alternatives such as get_mastery_path for the current state. Usage context is implied, not fully specified.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds behavior by specifying the output is a compact summary with total count, progress, next point, and due reviews. This is useful context beyond annotations.

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

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

A single sentence that packs the purpose, the scope, the output content, and an alternative into one breath. Nothing extraneous, 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?

For a list tool with an output schema, the description tells the agent what the output contains and when to use this versus the sibling. No missing instructions for correct invocation.

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

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

There are zero parameters and schema coverage is complete, so the description needs no parameter explanations. The baseline for 0 params is 4, and the description doesn't under-deliver.

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

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

States a specific verb ('list'), resource ('Mastery Path'), and scope ('every'), and enumerates the summary fields (count, progress, next point, due reviews). It explicitly distinguishes itself from get_mastery_path by noting that tool provides the full outline.

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 names the alternative get_mastery_path and directs when to use it ('for the full outline'), which clearly frames this tool as the summary-only variant. No ambiguity about when to use which.

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=true and destructiveHint=false, so the agent knows this is a safe read. The description adds no further behavioral context such as ordering, depth, or scope, but for a parameterless list operation this is a minor omission.

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

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

A single, front-loaded sentence that wastes no words. Every token contributes meaning.

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

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

Given the absence of parameters, the read-only annotations, and the presence of an output schema, the description contains everything needed to invoke the tool correctly. No return-value documentation is required because 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?

The tool has zero parameters, and the schema description coverage is 100%, so there is nothing left for the description to document. Per the baseline for parameterless tools, this is effectively complete.

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

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

The description uses a specific verb ('List') and a clear resource ('DeepTutor notebooks'), immediately distinguishing this collection-returning tool from siblings like get_notebook, create_notebook, and list_books. No ambiguity remains about what operation is performed.

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

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

The verb 'List' implies this is the collection-level retrieval tool, while siblings like get_notebook handle individual notebooks. However, the description gives no explicit guidance on when to choose this over those alternatives or whether any filtering is available.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds no extra behavioral context beyond the fact that it lists categories. It does not mention ordering, pagination, or any special behavior, but those are not critical for a simple read-only operation.

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

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

The description is a single, succinct sentence with no filler. It is front-loaded and every word earns its place. This is appropriately sized for a simple list 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 straightforward with one optional parameter and an output schema that presumably details the returned categories. The description is adequate but could benefit from explaining what 'native' means or how categories relate to question entries. However, given the existence of an output schema and the tool's simplicity, the missing context is not critical.

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

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

The schema description coverage is 100% for the single optional parameter course_id, which is described as 'Optional course ID' in the schema. The description itself does not add any additional semantic detail to the parameter, so it meets the baseline but provides no extra value.

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

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

The description 'List native Question Bank categories' clearly states a specific verb (list), a resource (Question Bank categories), and a qualifier ('native'). It is unambiguous and distinct from sibling tools like list_question_entries, though it does not explicitly differentiate from them.

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

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

There is no guidance on when to use this tool versus alternatives. No exclusions or context about how it relates to list_question_entries or other question-bank tools are provided. An agent would have to infer its usage from the name.

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

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

Annotations already establish this as a safe read-only operation, and the description is consistent with that. However, the description adds little behavioral context beyond the annotations—no mention of defaults, filter combination semantics, or return shape, though the output schema covers part of 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, front-loaded sentence with zero filler. Every word contributes to identifying the operation and resource.

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

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

For a read-only list/search tool, the description plus a fully documented schema, safe annotations, and an output schema is nearly complete. It loses a point only because it gives no hint about how to choose among the many related question and mastery-path siblings.

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

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

Schema description coverage is 100% for all 9 parameters, so the schema carries the semantic load. The description adds only the generic idea of search/filter and does not elaborate on any parameter beyond what the schema already states.

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

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

The description names a specific action ('Search and filter') and a specific resource ('DeepTutor's native Question Bank'), making the collection-level intent unmistakable. It is clearly distinct from single-entry siblings like get_question_entry and from category listing tools like list_question_categories.

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 instead of get_question_entry, list_question_categories, or other question-related tools. There are no stated exclusions or conditions, so the agent must infer usage from the tool name and schema.

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, so the safety profile is clear. The description adds the content type (highlights and notes) but no additional behavioral details such as ordering or pagination. With annotations covering safety, this is adequate but not rich.

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

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

A single sentence with zero waste, front-loaded with the action. The description is appropriately sized for the tool's simplicity.

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

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

For a simple read-only list tool with one parameter and an output schema, the description is sufficient. No missing information an agent needs to call it correctly, given the output schema covers 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 documentation for material_id is complete ('Reading material ID'), so the description adds no extra meaning. Baseline 3 applies because the schema carries the parameter explanation.

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

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

States a specific verb 'Read' and resource 'highlights and notes on a material', clearly distinguishing this from save/delete variants in the sibling list. The name matches and the resource type is explicit.

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

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

No guidance on when to use this tool versus alternatives like save_reading_annotation or list_reading_bookmarks. Context is implied by the name but not explicitly stated, leaving the agent to infer when this is the right choice.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. However, it adds no behavioral context beyond those annotations; 'on a material' merely restates the schema's material_id scope, with no mention of ordering, pagination, or relationship to annotations.

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

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

The description is a single front-loaded sentence with no filler. For a one-parameter read-only list tool, this level of brevity is appropriate and every word earns its place.

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

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

Given the read-only annotation and the presence of an output schema, the basic invocation details are covered. Still, the description does not clarify whether it returns all bookmarks for the material or how it should be chosen over the add/delete bookmark siblings, leaving some inference to the agent.

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

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

Schema coverage is 100%, with material_id already described as 'Reading material ID'. The description's 'on a material' adds no new parameter meaning, so the baseline score of 3 applies because the schema carries the parameter documentation.

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

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

The description uses a clear verb ('Read') and resource ('bookmarks on a material'), so an agent can identify this as a retrieval operation scoped to a single reading material. It is distinguishable from the add/delete bookmark siblings by the read verb, though it does not explicitly name them or emphasize the 'list' behavior.

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

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

There is no guidance on when to use this tool versus alternatives such as add_reading_bookmark, delete_reading_bookmark, or list_reading_annotations. The read-only wording implies retrieval, but no condition, prerequisite, or exclusion is provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the 'imported' scope qualifier; it does not describe pagination, ordering, or other behavioral details, but for a simple read-only list with an output schema this is minimally acceptable.

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

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

The description is a single clear sentence with no wasted words. It states the operation and resource efficiently.

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

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

Given no parameters, read-only annotations, and an existing output schema, the description does not need to explain return values. However, it lacks any context about what counts as 'imported reading materials' or how this tool relates to sibling list/get tools, leaving an agent to infer the intended use case.

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

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

The input schema has no properties, and schema_description_coverage is effectively 100% because there are no parameters to document. The description has no need to elaborate on parameter 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 states a clear verb and resource: 'List imported reading materials.' It is distinguishable from get_reading_material and list_reading_bookmarks, but 'reading materials' is left undefined relative to similar tools like list_books, so it does not fully achieve sibling differentiation.

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

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

There is no guidance about when to use this tool versus alternatives such as list_books, get_reading_material, or list_reading_bookmarks. The description does not state prerequisites, expected context, or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description need not repeat that. It adds the 'up to 90 days' limit and the nature of the data returned (trends and source counts), but it does not disclose any other behavioral traits like response formatting, pagination, or how timezone defaults work. Given the annotation coverage, this is adequate but not rich.

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

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

The description is a single sentence with no filler, front-loading the verb 'Read' and the core resource. It is efficient and easily scannable, though it could have been slightly more structured to mention the optional filters.

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 values are already specified. However, the description does not explain what 'source counts' means or how the optional parameters (course_id, all_workspaces, timezone) affect the results. For a read-only analytics tool with multiple filters, this is minimally complete but lacks depth that would help an agent choose and invoke it confidently.

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

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

Schema description coverage is 100%, so all four parameters are already documented. The description echoes the 'up to 90 days' constraint for the days parameter but does not add meaning to timezone, course_id, or all_workspaces, nor does it explain how these filters interact. Baseline 3 is appropriate when the schema carries the 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 clearly states a specific verb ('Read') and resource ('practice trends and source counts') with a constraint ('up to 90 days'). It distinguishes itself from generic practice tools by focusing on analytics, but it does not explicitly name or differentiate from siblings like practice_summary or practice_queue, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or conditions that would route an agent to practice_summary or practice_queue instead. The purpose is clear, but usage context is left entirely to the agent's inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the behavioral trait that only due items are returned, but it does not describe pagination or the shape of the returned queue. With annotations carrying the main burden, 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?

The description is a single, front-loaded sentence with no filler. Every word contributes meaning: it names the action, the resource, and the selection criterion ('due').

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 queue tool, the description, fully documented schema, annotations, and existing output schema provide everything an agent needs to call it correctly. There are no hidden prerequisites or unexplained side effects.

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

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

Schema description coverage is 100%, so all three parameters (limit, timezone, all_workspaces) are already documented in the input schema. The description adds no additional parameter-level 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 uses a specific verb ('Read') and resource ('due Question Bank practice items'), clearly distinguishing this queue-list tool from siblings like get_practice_question, which targets a single item, and record_practice_review, which records results. An agent can identify what this tool does without opening the schema.

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

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

The description clearly implies 'use this when you want the currently due practice items,' which is sufficient context for a read-only queue. It does not explicitly name alternatives or exclusions, but the sibling list and the phrase 'due' provide enough situational guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the verb 'Read' is consistent with that safety profile. The description adds the specific data categories returned but does not mention any additional behavior such as workspace scoping or timezone effects; with annotations present, the additional burden is limited.

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

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

The description is a single front-loaded sentence that names exactly what the tool reads. Every word earns its place and there is no filler or redundant restating of the tool name.

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

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

For a simple read-only summary tool, the description plus annotations and output schema cover the core semantics: safety, return categories, and optional parameter meanings. It is slightly incomplete only in not routing the agent away from overlapping siblings like practice_analytics.

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 schema already documents 'timezone' (IANA, defaults to Asia/Shanghai) and 'all_workspaces' (include all available workspaces). The description adds no parameter-level meaning, so the baseline 3 applies because the structured schema carries the full weight.

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

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

The description uses a clear verb and resource: it reads practice counts, due items, and next due time. This distinguishes it from question/answer/record tools, though it does not explicitly differentiate it from practice_analytics or clarify whether counts are workspace-wide or scoped.

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

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

There is no guidance on when to choose this tool over siblings such as practice_analytics, practice_queue, or learning_overview. The description gives no selection conditions, exclusions, or alternative tool names.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the 'bounded original text slice' constraint, which is useful behavioral context (it reads a slice, not the whole file). It does not mention rate limits, authentication, or error behavior, but given annotations, a 3 is appropriate – it adds some value without contradicting structured data.

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

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

The description is a single sentence with no filler. It front-loads the core action and scope, then adds the exclusion. Every word earns its place.

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

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

With annotations covering safety, a full input schema, and an output schema (per context), the description is sufficient for an agent to call the tool correctly. It lacks explicit notes on pagination or error cases, but for a simple bounded read operation, these are minor and partly covered by the schema. The description is complete enough.

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

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

Schema description coverage is 100%, so all parameters (offset, kb_name, filename, max_chars) have individual descriptions. The description's 'bounded original text slice' phrasing implicitly explains how offset and max_chars relate (bounding the slice), adding slight meaning beyond the schema. However, it does not elaborate on the interplay or defaults, so it does not significantly exceed 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?

Description states a specific verb ('Read'), a resource ('knowledge base file'), and a bounded scope ('a bounded original text slice'), and explicitly excludes DeepTutor answer generation, distinguishing it from that sibling. It is immediately clear what the tool does and how it differs from answer-generation 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 clear context for use: reading a bounded original text slice from a knowledge base file. It also provides an exclusion ('no DeepTutor answer generation'), which prevents misuse for answer generation. However, it does not explicitly name alternatives like search_knowledge_file or list_knowledge_files or state when to use this over them, so it falls short of full guidance.

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

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

The description explicitly warns that the tool 'Changes stored DeepTutor learning data,' which goes beyond the annotations (readOnlyHint: false, destructiveHint: false) by clarifying the nature of the write operation. It also adds a caution to check ID and values and to call only on explicit request, providing important behavioral context for a mutation tool. No contradiction with annotations.

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

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

The description is concise, comprising two sentences with no fluff. The warning is front-loaded, immediately alerting the agent to the data-changing nature and the need for authorization. The structure efficiently conveys the main purpose and key cautions without repetition.

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

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

For a write operation with seven parameters and only minimal annotations, the description provides essential warnings about data modification and authorization requirements. Combined with the fully documented schema and the presence of an output schema, the description covers the critical context an agent needs to invoke the tool correctly. Minor omissions, such as mention of the confirm flag's purpose, are already handled by the schema, so the completeness is high.

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, with each parameter fully described. The description adds minimal semantic value beyond the schema, only reinforcing the importance of 'current version' and 'unique request ID.' While these hints are useful, they largely paraphrase schema details, so the baseline score of 3 applies as schema does the heavy lifting.

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

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

The description states the action clearly: 'Record a completed review' using specific details (current version and unique request ID). This gives a specific verb and resource, making the tool's purpose unambiguous. It does not explicitly differentiate from siblings, but the action is distinct enough among the listed tools; a slight deduction for lacking explicit sibling distinction.

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

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

The description provides a clear condition for when to use the tool: 'call only when the learner explicitly requests this action.' This is a useful usage guideline that prevents misuse. However, it does not mention alternatives or when not to use the tool relative to other review/answer tools like check_practice_answer, so guidance is partial.

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 warning explicitly states this tool 'Changes stored DeepTutor learning data,' reinforcing the destructiveHint annotation with operational context. It adds meaningful safety guidance: check the target ID and values, require explicit learner authorization, and review before replacing. This exceeds what annotations alone provide.

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

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

Two sentences carry the essential warning and the core action with no filler. The safety warning is front-loaded, and the action statement is placed after the caution, giving the agent the critical context first.

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 replace operation, the description covers the key context: it mutates stored data, requires explicit user authorization, and warns to verify target and values. Combined with the complete input schema and output schema, an agent has everything needed to invoke it safely and correctly.

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

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

Schema description coverage is 100% and the schema already documents course_id, units, and confirm clearly. The description's warning to 'Check the target ID and values' broadly maps to parameters but adds no specific parameter semantics beyond what the schema provides, matching the baseline for high schema coverage.

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

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

The description names the specific verb and resource: 'Replace a course's full syllabus', making the operation clear. It also clarifies scope with 'full syllabus', which distinguishes it from sibling tools like set_course_unit_covered that operate on individual units.

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 an explicit condition for use: 'call only when the learner explicitly requests this action', and frames the action as requiring review. It does not name alternatives or explicitly state when not to use it beyond the learner-request constraint, so it misses the top score for alternative routing.

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

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

Annotations already mark this as destructive, and the description adds meaningful context: it changes stored DeepTutor learning data, preserves supplied IDs, and checks revision. This goes beyond the annotation by explaining what the write operation does and what safeguards exist.

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-loads the critical warning before the action. Both sentences earn their place, though the warning could be slightly more concise without losing meaning.

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

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

For a destructive write tool, the description covers the key safety and workflow considerations: explicit user authorization, revision checking, and full replacement. With a complete schema and output schema present, 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?

Schema description coverage is 100%, so the schema already documents each parameter. The description adds a bit of behavioral context around expected_revision and modules, but does not materially enhance parameter understanding 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 action as replacing the full mastery outline, a specific verb and resource. It distinguishes this from sibling get/set/list tools by emphasizing the full replacement and revision check.

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

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

The description explicitly states when to call the tool: only when the learner explicitly requests the action, and after review. It does not name alternative tools, but the warning and conditionality provide clear 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?

Even though annotations already indicate readOnlyHint=false and destructiveHint=false, the description adds valuable behavioral context by warning that it 'Changes stored DeepTutor learning data' and emphasizing the need for explicit user authorization. This goes beyond the annotations and helps the agent understand the write 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?

The description is short and front-loaded with the most critical warning, followed by a usage instruction and a clear action statement. There is minor redundancy with the confirm parameter's schema description, but overall it is efficient.

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

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

For a 9-parameter mutation tool with complete schema coverage and an output schema present, the description covers safety and usage requirements well. It does not need to explain return values, and the warning about explicit user consent fills an important contextual gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not explain individual parameters beyond listing annotation kinds, which duplicates the schema. It adds no new semantic detail for material_id, locator, note, color, or confirm.

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 'Create or update' and the resource 'a highlight, underline, note or citation on a material', making the tool's purpose specific and unambiguous. It also names the exact annotation kinds, which distinguishes it from related tools like delete_reading_annotation and list_reading_annotations.

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

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

The description explicitly states when to call the tool ('call only when the learner explicitly requests this action') and warns to 'Check the target ID and values'. This provides clear usage context and a key prerequisite, though it does not explicitly name sibling alternatives for when not to use it.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds one meaningful behavioral trait—that no DeepTutor model call is made—but does not disclose limit defaults, case sensitivity, or error behavior when no matches exist.

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

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

A single, front-loaded sentence states the core behavior and the critical non-behavior ('no DeepTutor model call'). Every word earns its place, and the description is neither padded nor underspecified.

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 100% schema parameter coverage, readOnly annotations, and an existing output schema, the description provides the one crucial contextual distinction—literal search without model invocation. Minor missing details like result limits or search semantics are already handled by the schema and output schema, so nothing essential is absent.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema. The description reinforces that 'query' is a literal phrase, matching the schema's 'Literal phrase to find', but contributes little meaning beyond what the schema already states. 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 names a specific verb ('find'), a specific resource ('one knowledge base file'), and the exact behavior ('literal text matches'). It also explicitly distinguishes itself from a model-based search via 'no DeepTutor model call', which differentiates it from search_vector_knowledge without needing to inspect that sibling.

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

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

The description implies the tool is for exact literal search within a single file, and the phrase 'no DeepTutor model call' hints that it is the cheaper/non-semantic alternative. However, it does not explicitly state when to choose this over read_knowledge_file or search_vector_knowledge, leaving usage conditions 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 read-only and non-destructive behavior. The description adds useful behavioral detail beyond that: it 'Uses the configured query embedding' and explicitly disclaims conversation/answer synthesis, giving the agent a clearer model of what happens at invocation.

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

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

Two compact sentences that front-load the primary action and then add the key exclusions. Every phrase earns its place, with no filler or redundant restatement of schema fields.

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 full parameter schema, output schema, and annotations available, the description covers the essential role and boundaries of the tool. Nothing an agent needs to decide whether to invoke it or 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description only reinforces that kb_name selects a knowledge base and that query is a search phrase, adding no substantive parameter-level meaning 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?

Specifies a concrete action and resource: 'Retrieve original indexed passages from one DeepTutor LlamaIndex knowledge base.' It also distinguishes itself from conversation/answer tools via 'does not start a DeepTutor conversation or synthesize an answer,' which differentiates from siblings like send_message_to_deeptutor.

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

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

Provides clear context by stating it retrieves raw passages rather than synthesizing answers, giving an implicit when-not-to-use. However, it does not explicitly name sibling alternatives such as search_knowledge_file or state when one should choose that tool over this one.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds minimal behavioral context—it mentions the 'direct conversation' aspect but doesn't describe what happens when a message is sent (e.g., whether it creates a session, returns a response, or affects memory). While not contradicting annotations, it doesn't enrich behavioral transparency beyond the guardrail.

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, dense sentence that front-loads the usage condition. It wastes no words and conveys the essential guidance efficiently. The structure is ideal for quick parsing by an agent.

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

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

Given the tool's moderate complexity (5 parameters, 3 required) and the presence of a fully descriptive schema and an output schema, the description is sufficient for correct invocation. It covers the key usage trigger (explicit request) and the alternative (Codex). Minor context like how session_id interacts or what happens without it is already handled by the schema, so 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?

Schema description coverage is 100%, meaning each parameter is already described in the schema. The description does not add additional parameter-level meaning beyond restating the condition for direct_dt_conversation. Since the schema handles parameter semantics fully, the baseline of 3 applies—the description neither enhances nor detracts.

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

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

The description clearly states the tool's purpose: 'send_message_to_deeptutor' is for conversing directly with DeepTutor. It specifies the exact condition ('only when the user explicitly asks to converse directly with DeepTutor') and differentiates it from Codex, which handles ordinary tutoring. This makes the tool's role unambiguous and distinct from siblings like deeptutor_status or list_deeptutor_sessions.

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

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

The description provides explicit usage guidance: it tells the agent when to use this tool (only upon explicit user request for direct DeepTutor conversation) and when not to (Codex handles ordinary tutoring). It names the alternative (Codex) and sets a clear boundary, so the agent can decide correctly without confusion.

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 only say the tool is not read-only and not destructive; the description adds that it 'changes stored DeepTutor learning data,' warns to check IDs/values, and requires explicit learner authorization. This materially enriches the safety profile.

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

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

Three short sentences, each earning its place: warning, invocation gate, and semantic clarification. Front-loading the warning is appropriate for a state-changing 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 four-parameter boolean update with a full input schema and an output schema, the description supplies the missing behavioral and authorization context. No obvious gaps remain.

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 covers 100% of the four parameters with descriptions, so the schema carries the semantic load. The description only adds a caution to check target IDs and values rather than per-parameter 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 names the exact action ('Mark one syllabus unit covered or uncovered') and resource (syllabus unit in a course). It also clarifies the record's meaning ('learner record, not proof of mastery'), which separates it from mastery-related 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?

Explicitly gates invocation to 'call only when the learner explicitly requests this action,' and warns to verify the target ID and values before calling. This gives a clear when-to-use signal even without naming alternatives.

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

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

Annotations already declare readOnlyHint false and destructiveHint false. The description adds that it 'Changes stored DeepTutor learning data', warns to check target ID and values, and emphasizes the action is a learner declaration, not an inference. This enriches the behavioral context beyond the annotations without contradiction.

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

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

Two sentences, both essential. The warning is front-loaded, and the second sentence defines the exact purpose. Zero fluff, maximum information density.

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

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

For a mutating tool with 5 parameters and a confirm flag, the description explains the core purpose and the critical condition. The output schema exists, so return values need not be described. Minor gaps like potential side effects or prerequisites are not covered, but overall it is complete enough for correct invocation.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The tool description does not add extra meaning beyond the schema; for example, the `confirm` parameter's authorization semantics are already in 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 states a specific action: 'Record an explicit learner declaration of mastery or non-mastery', and clearly identifies the resource (DeepTutor learning data). It distinguishes itself from siblings by being the only tool that sets a learner override. The verb 'set' and the explicit scope 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?

Provides explicit guidance on when to use: 'call only when the learner explicitly requests this action' and 'never infer this from Codex conversation alone'. This is strong usage direction, though it does not name alternative tools. The condition is clear enough for an agent to decide correctly.

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