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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds value by specifying that all requests use Canvas GET endpoints and that the server cannot modify Canvas, which reinforces the read-only nature in operational terms. It also discloses the return content (requirements, rubric, submission summary), going beyond the annotations.

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

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

The description is two sentences, both purposeful. The first sentence establishes the read-only capability, and the second states the specific action and return content. No wasted words 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?

Given the simple two-parameter schema and absence of an output schema, the description adequately covers what the tool returns (requirements, rubric, submission summary) and its safe read-only nature. It does not mention pagination or errors, but for a single-assignment GET endpoint with strong annotations, this is sufficient for an agent to select and 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 description coverage is 0%, so the description carries the burden of explaining parameters. It only says 'Read one assignment' but never clarifies that course_id and assignment_id are the identifying IDs, nor does it add format, source, or constraints beyond the schema. The parameter names are self-explanatory, but the description contributes no additional semantic meaning.

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

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

The description clearly states the verb 'read' and the resource 'one assignment', specifying what is read: requirements, rubric, and submission summary. This distinguishes it from siblings like canvas_get_submission (which likely focuses narrowly on submissions) and canvas_list_assignments (which lists rather than reads one).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 for when to use the tool: when you need a single assignment's details including rubric and submission summary. It does not explicitly mention alternatives or exclusions, but the read-only scope and singular resource imply when it is appropriate versus listing or grade-focused tools.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds that all requests use Canvas GET endpoints and the server cannot modify Canvas, which reinforces the safety but does not add substantial behavioral context beyond the annotations. No contradiction.

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

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

Two concise sentences, front-loaded with the read-only nature and a clear statement of functionality. Every word earns its place with no redundancy or fluff.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description adequately conveys the two operational modes (grade totals vs. assignment breakdown). It could benefit from an example or return format, but it is sufficient for basic use.

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

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

The schema covers 0% of the parameter description, so the description must compensate. It does by implying that providing course_id yields a specific course's assignment breakdown, while omitting it returns grade totals. This gives meaningful behavior to the optional 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 clearly states the tool reads grade totals or a course's assignment breakdown, which is a specific verb+resource and distinguishes it from siblings like canvas_get_assignment or canvas_get_submission. However, it does not explicitly name alternatives or provide details on the response format.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 vs alternatives. The description mentions read-only access but does not say when to choose this over canvas_list_assignments or canvas_get_submission, nor does it provide any exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is well covered. The description adds that all requests use Canvas GET endpoints and that the server cannot modify Canvas, reinforcing read-only behavior without introducing new behavioral details. There are no contradictions 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 two sentences and does not waste words. The first sentence about read-only access is somewhat redundant with the annotations but still provides useful server-level context. Overall, it is concise and front-loaded with the key 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?

For a simple tool with no output schema, the description covers the primary purpose and read-only nature, but it does not explain the course_id parameter or mention what the response contains. This leaves some gaps, but the tool is simple enough that a 3 is appropriate.

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

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

With schema description coverage at 0%, the description must compensate, but it only clarifies page_url as a 'CANVAS page URL slug' and leaves course_id unexplained. This is insufficient for a 2-parameter tool, and the description adds no details about integer IDs or required format beyond the schema.

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

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

The description states a specific action: 'Read one course page by its Canvas page URL slug.' This clearly identifies the resource (course page) and the identifier (URL slug), making the tool's purpose distinct from sibling tools like canvas_list_courses. However, it does not explicitly name alternative tools, so it misses the highest score.

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

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

The description implies when to use the tool: when a single course page is needed by its URL slug. It provides context that the server is read-only, but does not specify when not to use this tool or mention alternative tools (e.g., canvas_get_syllabus). The guidance is clear but not explicit enough for a 4.

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

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

The description adds behavioral context beyond the annotations: it explicitly states all requests use Canvas GET endpoints and that the server cannot modify Canvas. It also discloses the scope ('current user'), which is not present in the readOnlyHint annotation. While the annotations already cover the read-only safety profile, the description reinforces and adds user-scoping details.

Agents need to know what a tool does to the 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 short sentences, each serving a distinct purpose: establishing read-only access, reinforcing GET usage, and specifying the exact data returned. There is no unnecessary verbiage, and the most important information is front-loaded. This is highly concise and well-structured.

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

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

The tool lacks an output schema and has only basic parameter names. The description lists the return components (submission, comments, rubric assessment) but does not explain the response structure, potential error conditions, or whether the submission might be absent. For a simple read-only tool, this is adequate but leaves room for ambiguity. Sibling differentiation is present but not exhaustive.

Complex tools with many parameters or behaviors need more documentation. 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 0%, so the description must compensate for the absence of parameter documentation. However, the description does not mention course_id or assignment_id at all, nor does it explain their meaning, constraints, or how they relate to the current user's submission. The parameter names are self-explanatory, but the description adds minimal semantic value beyond the schema structure.

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

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

The description clearly states the tool's function: 'Read the current user's submission, comments, and rubric assessment.' It uses a specific verb ('read') and identifies the resource ('submission') and distinguishes itself from siblings by specifying the current user and the included components. The read-only nature is also explicit, separating it from any modifying 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 provides clear context: it is read-only and uses GET endpoints, so it is safe to use. It implicitly indicates when to use it (when needing the current user's submission for a course/assignment) but does not explicitly mention alternatives or exclusions. This aligns with 'clear context, no 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 read-only, idempotent, and non-destructive behavior. The description adds value by stating that all requests use Canvas GET endpoints and that output is 'cleaned text', providing useful behavioral context beyond the annotations.

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

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

The description is concise, consisting of two sentences that are front-loaded with the primary purpose. No redundant words or unnecessary details.

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

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

For a simple read-only tool with a single parameter and strong annotations, the description is complete. It conveys the read-only nature, the output format (cleaned text), and the resource being accessed. No output schema exists, but the description provides enough about the return value.

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

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

The schema has one required parameter, course_id, with no description. The tool description does not elaborate on the parameter, but the parameter name and tool purpose make its meaning obvious. The description does not compensate for the 0% schema coverage, but the gap is minimal.

Input schemas describe structure but not intent. Descriptions should explain 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 reads one course syllabus as cleaned text, specifying the exact resource and action. It distinguishes itself from sibling tools like canvas_list_courses and canvas_get_assignment by focusing specifically on syllabi.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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: use this tool to read a single course syllabus. It does not explicitly mention exclusions or alternatives, but the context is sufficiently clear given the tool name and sibling set.

Agents often have multiple tools that could apply. Explicit usage 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 and non-destructive behavior; the description explicitly reinforces this with 'All requests use Canvas GET endpoints; this server cannot modify Canvas,' adding natural-language clarity beyond the hints, though no additional behavioral details like rate limits are given.

Agents need to know what a tool does to the 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 but contains redundancy: the first two sentences both express read-only behavior. The third sentence delivers the core purpose. Could be more concise by merging the first two.

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

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

For a simple list tool with no output schema, the description covers scope (one/all courses) but omits details like return fields, pagination, or how 'recent' is determined. It is adequate but not fully complete.

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

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

The schema provides no descriptions (0% coverage). The description hints at course_id via 'one or all active courses' and recency for since_days, but it does not explicitly explain either parameter's semantics, ranges, or defaults. It adds some meaning but leaves gaps.

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

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

The description clearly states the tool lists recent announcements for one or all active courses, using the specific verb 'list' and resource 'announcements'. This distinguishes it from sibling tools like canvas_list_courses and canvas_list_assignments.

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

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

It implies use when announcements are needed and clarifies that it works for a single course or all active courses, but does not explicitly name alternative tools for other resources or state when not to use.

Agents often have multiple tools that could apply. Explicit usage 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 and idempotentHint, but the description adds concrete behavioral context: 'All requests use Canvas GET endpoints; this server cannot modify Canvas.' This goes beyond the annotation hints and clarifies the exact HTTP method.

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

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

The description is compact and front-loaded with the read-only nature. However, the first sentence ('Read-only Canvas LMS access.') is mostly redundant with the annotation, and the second sentence restates 'cannot modify Canvas.' Overall, it is concise but not maximally 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?

With no output schema and three parameters, the description should explain return values and parameter effects. It only covers the overall purpose. Missing details about pagination (limit), filtering (bucket), and course_id scope make it incomplete for an agent to invoke effectively.

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

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

Schema description coverage is 0%, and the description gives no explanation of the parameters (limit, bucket, course_id). With three optional parameters, the description should compensate by explaining their semantics, but it only mentions 'one course or all active courses,' which is insufficient.

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

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

The description states a specific verb and resource: 'List assignments for one course or all active courses.' This clearly distinguishes it from siblings like canvas_get_assignment (single assignment) and canvas_list_courses (lists courses).

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

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

The description implies usage by stating the tool lists assignments, and the scope 'for one course or all active courses' provides context. However, it does not explicitly mention alternatives or when not to use it, leaving room for ambiguity.

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

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

The annotation set already declares readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the note that 'all requests use Canvas GET endpoints' and 'cannot modify Canvas,' which is slightly more specific but largely redundant with the annotations. No additional behavioral details like return format/pagination are provided, but the annotations reduce the burden.

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

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

The description is two sentences with no fluff. The first sentence about read-only access is somewhat generic and overlaps with annotations, but it is brief. The second sentence directly states the tool's purpose. Overall, it is concise and well-structured, though the first sentence could be trimmed.

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

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

The tool has no output schema, so the description carries the burden of explaining return values. It mentions listing active courses, terms, and current scores, but 'available current scores' is somewhat vague and could be interpreted as needing more detail about what fields are returned or how scores are formatted. No mention of pagination or scope limitations beyond 'active' courses, leaving a moderate 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 tool has zero parameters, and the schema is empty, so the baseline is 4. The description doesn't need to explain parameters, and the listing of outputs (courses, terms, scores) adds context without describing parameters.

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

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

The description clearly states the tool's function with a specific verb and resource: 'List active courses, terms, and available current scores.' This distinguishes it from sibling tools like canvas_list_assignments or canvas_get_grades, which target different resources.

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

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

The description provides clear context for when to use the tool: when a listing of active courses, terms, or current scores is needed. While it doesn't explicitly mention alternatives, the differentiation from sibling tools is implied through the resource list, and the read-only nature is stated. No explicit exclusions are given, but the usage intent is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reiterates read-only behavior with 'All requests use Canvas GET endpoints; this server cannot modify Canvas.' It adds the GET endpoint detail but provides no further behavioral context such as pagination, rate limits, or return format beyond what annotations cover.

Agents need to know what a tool does to the 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 free of fluff, but the tool-specific purpose is placed at the end after generic read-only context. While concise, the front-loading could be improved by leading with the actual action.

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

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

For a simple list tool with no output schema, the description covers the basic action and scope. However, it omits details like whether search matches file names, pagination behavior, or what file attributes are returned. Given the absence of an output schema, the description should provide more 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?

With schema description coverage at 0%, the description compensates by explaining course_id as 'one course' and search as an 'optional search term.' It gives basic semantic meaning to both parameters, though it does not elaborate on how search matches files (e.g., name vs. content).

Input schemas describe structure but not intent. Descriptions should explain 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 'List files in one course with an optional search term,' which identifies the verb (list), resource (files), and scope (one course with search). This distinguishes it from siblings like canvas_list_courses and canvas_read_file.

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

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

The description implies usage when you need to list files in a course, but it does not explicitly state when to use this tool over alternatives or provide exclusions. The read-only note is generic, not specific to this tool's selection.

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

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

Annotations already declare readOnlyHint and destructiveHint, but the description adds specific context: 'All requests use Canvas GET endpoints; this server cannot modify Canvas.' This reinforces the safety profile and gives additional behavioral detail without contradicting annotations.

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

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

Two concise sentences with front-loaded context. Every sentence adds value, avoiding fluff while covering purpose and read-only nature.

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

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

For a simple one-parameter read-only list tool with strong annotations, the description is complete. It states exactly what is listed (modules and module items) and the read-only constraint, making it 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?

The only parameter, course_id, is not explicitly described, but the phrase 'one course's modules' implies its meaning. With schema description coverage at 0%, the description only partially compensates, though the parameter is self-explanatory from its name.

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

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

The description clearly states the tool 'List one course's modules and module items', using a specific verb and resource scope. This distinguishes it from sibling tools like canvas_list_courses and canvas_list_assignments.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use for read-only listing of modules but does not explicitly compare to alternative tools or state when not to use it. The read-only context is helpful, but no exclusions or alternative recommendations 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, idempotentHint, and destructiveHint false. The description adds 'All requests use Canvas GET endpoints; this server cannot modify Canvas,' which reinforces the annotation but adds little extra behavioral context such as authentication, error behavior, or download size limits.

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

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

The description is two sentences long, front-loaded with the key read-only context, and contains no filler. Every word contributes to explaining the tool's scope and safety.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 read-only tool with ample annotations, the description covers safety and basic scope. However, it leaves ambiguity about the return format (file content vs. metadata/URL) and the exact download behavior, making it incomplete for an agent deciding how to invoke and interpret the result.

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

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

Schema description coverage is 0%, and the description only implies that course_id identifies the course and file_id identifies the file. It does not explain how to obtain these IDs or clarify the relationship beyond 'belongs to a course,' so it fails to compensate for the lack of schema descriptions.

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

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

The description uses a specific verb 'Read or safely download' with a clear resource ('one file that belongs to a course'), distinguishing it from sibling list tools like canvas_list_files. This makes the tool's purpose immediately understandable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 read-only context and 'one file' phrasing imply when to use the tool, but there is no explicit when-not guidance or reference to alternatives such as canvas_list_files for discovering file IDs. The usage guidance is present only implicitly.

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