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

With no annotations, the description carries the full behavioral disclosure burden. It does disclose the important skip-same-size-and-force behavior, but it omits local filesystem side effects, overwrite/merge semantics, and any failure or exception conditions.

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 the core purpose front-loaded and a second sentence adding the key behavioral nuance. No filler or redundant phrases.

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

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

There is no output schema and no annotations, yet the tool performs local downloads and index generation. The description fails to explain return values, what indexes refer to, how output_dir is used, or what the operation returns on success or failure.

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 are already documented. The description adds no extra parameter semantics beyond what the schema provides, yielding the baseline score of 3.

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

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

The description states a concrete action ('Download course files locally and generate indexes') with a specific resource ('course files'), making the core purpose clear. It is not explicitly differentiated from sibling generate_course_index, but the download-first framing helps distinguish it from listing/planning 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?

No guidance is provided about when to use this tool versus alternatives like plan_course_download, generate_course_index, or list_course_files. The agent is left to infer the intended workflow from the name and sibling list.

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

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

With no annotations, the description carries the burden. It discloses a key behavioral trait (non-mutating, never submits or modifies work), which is valuable. However, it does not mention that it writes files to disk, how it handles existing files (except the force parameter in schema), or any network/error behavior. The single safety guarantee is useful but incomplete.

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

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

Two sentences with zero redundancy. The primary action and key safety guarantee are front-loaded. Every word contributes value.

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?

No output schema exists, so the description should explain what the tool returns or does beyond the action. It does not mention return values, potential disk usage, or timing. With five parameters, some explanation of how they combine (e.g., assignment_id vs. all submissions) is implicit in the schema but not in the description. Adequate but with gaps.

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

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

Schema description coverage is 100%, so all five parameters are already documented. The description adds no additional meaning about parameter usage or interactions beyond what the schema provides. 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 (download), the resource (my submitted assignment attachments), and the destination (locally). It also explicitly clarifies that it never submits or modifies work, distinguishing it from mutation tools. This is a specific verb+resource statement.

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 context (downloads my submissions) but does not explicitly state when to use this tool versus alternatives like download_course_files or get_my_submission. It only implies usage by naming the action; no exclusions or comparison to siblings are given.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions downloading images and assembling a PDF but does not state that files are written to disk, whether it performs network requests, how force affects behavior, or any side effects. The description is too sparse to give an agent confidence about the tool's runtime effects.

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

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

The description is a single, efficient sentence that front-loads the primary action (download) and the optional secondary action (assemble PDF). No filler or redundant phrasing; it earns its place in a dense, informative way.

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 6 parameters, no annotations, and no output schema, the description is not complete enough. It does not explain what the tool returns, what happens to existing files without force, where default output goes, or any error/edge-case behavior. An agent calling this tool would need to infer a lot from parameter names alone, which is risky for a download operation.

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

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

Schema coverage is 100% and every parameter has a description. The tool description adds minimal value beyond the schema—e.g., it mentions 'optionally assemble a local PDF' which relates to make_pdf and pdf_path, but it does not clarify the roles of force, output_dir, or the video_id source beyond what the schema already says. 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 specific action: 'Download PPT replay images for one SJTU video' and the optional 'assemble a local PDF'. It identifies the resource (PPT replay images) and the scope (one SJTU video), and it is distinct from sibling tools like get_video_ppt_slices which likely return slice metadata rather than downloading images.

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 you need the PPT images for a video) but does not explicitly mention alternatives or when not to use it. Sibling tools like get_video_ppt_slices or video_status are not referenced, so the agent gets no explicit routing guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions generating indexes and not downloading missing files, but omits details on side effects (e.g., file creation/overwriting), permissions, return values, or error behavior. This is a significant gap for a tool that presumably writes local files.

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

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

The description is a single, tightly-worded sentence that front-loads the core purpose and includes a distinguishing qualifier. Every word earns its place, with no redundancy or filler.

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

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

For a tool with two parameters and no output schema, the description covers the basic purpose but lacks essential context such as what the generated indexes contain, whether files are written to output_dir, what happens if files are missing, and any return or error semantics. It is minimally adequate but leaves gaps an agent must guess.

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% (both course_id and output_dir are described). The description adds no additional meaning beyond the schema – it mentions the output format but does not elaborate on parameter behavior. 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 tool generates local JSON/Markdown course indexes, and the qualifier 'without downloading missing files' distinguishes it from download-oriented siblings. However, it does not explicitly name an alternative or elaborate on scope beyond that, so it lacks the explicit sibling differentiation seen in top-tier descriptions.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like get_course_bundle or plan_course_download. The phrase 'without downloading missing files' implies a use case but does not state conditions, exclusions, or name any sibling, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It only says 'Return', implying a read operation, but does not mention error behavior (e.g., not found), permission requirements, or the structure of the returned course object. This is a significant gap for a tool without annotation coverage.

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

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

The description is a single, tightly worded sentence with no redundant information. It is front-loaded with the action and object, making it efficient for an agent to parse quickly.

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

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

For a simple fetch tool with no output schema, the description should at least hint at what is returned (e.g., course details) or error cases. It does neither, leaving the agent uncertain about the response format and failure modes. This is inadequate given the absence of both annotations and an output schema.

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

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

The schema already describes course_id as 'Canvas course ID' with 100% coverage, so the description adds no extra meaning. The baseline of 3 applies because the schema handles parameter documentation adequately; the description does not need to repeat it.

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

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

The description states a specific verb 'Return' and resource 'one Canvas course by ID'. It clearly indicates the tool fetches a single course, distinguishing it from list_courses by the ID qualifier, though it does not explicitly name alternatives. It is not a tautology because 'by ID' adds operational meaning.

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 like list_courses. It does not mention any prerequisites, context, or exclusions, leaving the agent to infer usage from the name and parameter 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?

No annotations are provided, so the description carries the full burden. It only states that it fetches multiple resource types, but doesn't disclose any behavioral details such as read-only nature, potential pagination, size limits, or response structure. It adds little beyond what the name implies.

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

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

The description is a single, clear sentence that front-loads the action and resource list. 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 single-parameter tool, the description adequately indicates what is fetched. It doesn't explain return format or pagination, but given the simplicity and no output schema, it is sufficient for an agent to call it correctly. A bit more detail on the aggregated structure would be nice, but it's not essential.

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 a single parameter, course_id, and the schema description already explains it as 'Canvas course ID' (100% coverage). The description adds no further meaning or syntax details, so it meets 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 states a specific action (fetch) and a specific resource set (course, folders, files, modules, assignments) in one call. It clearly distinguishes from sibling list tools by indicating a bundled fetch, though it doesn't name any sibling explicitly.

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

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

The phrase 'in one call' implies this is an alternative to calling multiple list tools individually. However, it doesn't explicitly state when to prefer this over the granular list tools, nor any exclusions or limitations. The context is clear but lacks explicit routing 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?

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that the tool validates the token, hinting at auth-related failure modes)Skip. However, it doesn't describe whether the operation is read-only or what happens on invalid tokens beyond validation.

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

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

The description is a single, focused sentence with no filler. It front-loads the main purpose and naturally conveys the token-validation behavior.

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

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

For a parameter-less, simple getter tool, the description is nearly complete. It lacks an explicit return-value shape, and there is no output schema, but 'current user profile' is reasonably self-explanatory in 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 tool has zero parameters)Skip, and schema coverage is complete. The description adds no parameter details, but none are needed; the baseline for zero parameters is 4.

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

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

The description clearly states a specific action ('Validate the Canvas token and return the current user profile') with an identifiable resource: the current user. This distinguishes it from sibling tools, none of which target the current user's profile.

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 clear usage: use this tool when you need to validate the token or retrieve the current user's identity/profile. It does not explicitly mention when not to use it, but there is no overlapping sibling for this purpose.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states 'This is read-only' and 'returns redacted URLs,' which tells the agent the operation is safe and that output is privacy-masked. It doesn't cover auth requirements or error behavior, but for a simple read tool this is meaningful and non-obvious 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?

Two short sentences, each earning its place: the first states the core purpose and scope, the second adds behavioral and output information. No redundancy or filler.

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

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

For a two-parameter read tool with a fully documented schema, the description covers the key non-obvious aspects: read-only behavior and redacted URL output. It is slightly incomplete in not mentioning how this relates to list_my_submissions or download_my_submission_files, but nothing critical is missing for 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% with clear descriptions ('Canvas course ID' and 'Canvas assignment ID'), so the schema already documents both parameters. The description adds no additional parameter-level meaning, matching the baseline of 3 for high coverage.

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

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

The description uses a specific verb ('Read') and resource ('my submission for one assignment'), clearly distinguishing it from list_my_submissions (multiple submissions) and download_my_submission_files (download vs read). The addition 'returns redacted URLs' further pins down the tool's 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 phrase 'for one assignment' implies when to use this tool versus listing or downloading submissions, but there is no explicit guidance on when not to use it or which sibling to prefer in alternate scenarios. The intended context is inferable, not stated.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Read' signals a non-mutating operation, and 'Returned payload is token-redacted' adds a meaningful privacy-related behavioral detail. It could mention auth or error behavior, but for a simple read tool this is solid coverage.

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

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

Two short sentences, no filler, and the core action is front-loaded. Every sentence contributes meaning: the operation and the notable token-redaction behavior. This 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 two-parameter read tool with full schema coverage, the description is mostly adequate. However, there is no output schema and the description does not enumerate what 'playback metadata' includes, so the agent cannot know what fields to expect. Minor usage guidance and response detail would make it complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond what the schema already documents, such as video_id being sourced from list_course_videos. It correctly implies both parameters identify a single video, but provides no additional 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 states a specific verb and resource: 'Read playback metadata for one SJTU video.' This clearly identifies the operation and scope. It does not explicitly differentiate from siblings like video_status or get_video_subtitle, but 'playback metadata' narrows the meaning well enough.

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

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

The description implies usage when a single video's playback metadata is needed, but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as video_status or get_video_subtitle, so the agent must infer the boundary.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool only reads metadata and has no image-download side effect, indicating a non-destructive operation. Yet it doesn't describe the exact output structure, potential errors, or prerequisites beyond the parameters, so transparency is only partial.

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

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

Two short sentences, each serves a purpose: the first states the action and object, the second clarifies a critical non-behavior to prevent misuse. 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 no output schema and no annotations, the description should specify what 'slice metadata' contains (timings, URLs, etc.), but it only says metadata. The two parameters are well-documented, and the tool is simple, yet the absence of return-value details leaves a moderate gap for an agent deciding whether this tool fits the task.

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 and the description adds little beyond the schema. It confirms 'one SJTU video' ties to video_id but doesn't explain how course_id relates or define 'slice metadata,' so no meaningful parameter semantics added.

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 the resource 'PPT replay slice metadata for one SJTU video,' which clearly defines the operation and scope. It also distinguishes itself from the sibling 'download_video_ppt' by stating it does not download images, preventing confusion with the download tool.

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

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

The description implies the use case: retrieving metadata without downloading images, which contrasts with download_video_ppt. However, it does not explicitly name alternative tools or give conditions like 'use this when you only need metadata.' Still, the negative statement provides clear selection 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?

No annotations are provided, so the description carries the full behavioral burden, but it only says 'Read subtitle rows' and 'return generated SRT text.' It does not disclose error behavior (e.g., missing subtitles), authentication needs, or any side effects, which is thin for a tool with zero annotation coverage.

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 states the action, scope, and result with no wasted words. Every phrase earns its place and the structure is immediately scannable.

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 tool with a fully documented schemaate, the description is adequate: it names the operation, scope, and output format. However, with no annotations and no output schema, some added context about edge cases (e.g., no subtitle rows) or when it should be used via a sibling would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents both parameters, and video_id's description ('from list_course_videos') adds useful sourcing context. The description itself adds no parameter-level detail, but none is needed.

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

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

The description uses a specific verb ('Read') with an explicit resource ('subtitle rows for one SJTU video') and names the output ('generated SRT text'). This clearly distinguishes it from video-related siblings like get_video_info and get_video_ppt_slices.

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

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

The description gives no guidance about when to choose this tool over alternatives, nor does it mention exclusions or prerequisites. It simply states what the tool does, leaving the agent to infer the appropriate use case.

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

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

With no annotations, the description must disclose behavioral traits. It does state 'read-only and never submits work,' which is a critical safety property. However, it doesn't mention any other behaviors like pagination, return format, or potential access requirements. For a simple read operation, 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?

Two concise sentences with no redundancy. The purpose is front-loaded, and the safety note is immediately relevant. Every word earns its place.

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

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

The tool has no output schema, so the description should explain what the agent can expect from the return value. It only says 'list assignments' without indicating the structure, fields, or whether assignments are ordered. Given the complexity of Canvas assignments (due dates, submission info), this is a significant gap. Additionally, it doesn't clarify whether it returns all assignments regardless of state (e.g., unpublished).

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 the single parameter course_id. The description adds no additional meaning to the parameter, such as format validation or how to obtain it. Baseline is 3 because the schema covers it, but the description doesn't enhance it.

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

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

The description clearly states the verb and resource: 'List assignments in one Canvas course.' It is specific about the scope (one course) and distinguishes from course-wide operations like list_courses or get_course, though it doesn't explicitly differentiate from other course-scoped listers like list_course_files or list_course_modules.

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

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

There is no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing a valid course_id, nor does it contrast with related tools like list_my_submissions or get_course_bundle. The only context is the read-only note, which is behavioral rather than usage direction.

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

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

With no annotations, the description carries the full burden. It only says 'List files,' without mentioning pagination, response format, ordering, or whether folders are included. This is insufficient for an agent to anticipate output or side effects.

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

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

A single, clear sentence with no unnecessary words. It is front-loaded with the action and resource. This is appropriately concise for a simple one-parameter tool.

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

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

The tool is simple (one parameter, no output schema), but the description still doesn't explain what the response contains or any limitations (e.g., pagination, file types). Given the absence of an output schema, the description should provide more context about the return value, making this incomplete.

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

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

Schema coverage is 100% — course_id is described as 'Canvas course ID.' The description adds no additional meaning beyond the schema. Baseline 3 is appropriate since the schema already fully documents the single 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 (list) and resource (files) with a clear scope (one Canvas course). It distinguishes itself from sibling tools like list_course_folders and download_course_files, though it could be more explicit about whether it lists all files recursively or only top-level.

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. Given the many sibling tools like list_course_folders and download_course_files, an agent would benefit from context on when to choose this one, but none is given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It signals a read-only listing operation and the course scope, but it does not mention whether folders are top-level only or recursive, nor pagination behavior, which are relevant for a folders API.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. Every word contributes to identifying the action, target, and scope.

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

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

This is a low-complexity tool with one fully documented parameter, so the description is mostly sufficient for correct invocation. The main gap is that there is no output schema and no statement about whether the returned folders are nested or flat, but the simplicity of the tool keeps this from being a major deficiency.

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 course_id is already clearly documented in the input schema as the Canvas course ID. The tool description adds no additional parameter-specific nuance, but the baseline score of 3 is appropriate because the schema already provides complete 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 uses a specific verb ('List') and resource ('folders') scoped to a single Canvas course, making it easy for an agent to distinguish this from sibling tools like list_course_files, list_course_modules, or list_course_assignments. It clearly answers what the tool does.

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

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

The intended usage is implied by the name and description: call this when you need folders within one course. However, it does not explicitly state when to prefer this over alternatives or provide exclusion criteria, leaving the choice somewhat 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?

No annotations are provided, so the description must carry the behavioral disclosure. It only says 'list' without mentioning pagination, response format, error behavior, or any side effects. For a read operation it is minimal, but it does not reveal potential limitations like number of modules returned or handling of invalid course IDs.

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

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

The description is a single sentence that is front-loaded with the primary action and includes the optional enhancement. Every word is necessary; there is no filler. This is an example of concise, effective communication.

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 no output schema and no annotations, the description is incomplete. It does not describe the return value structure (e.g., an array of modules), pagination, or any access requirements. An agent would not know what to expect from the call or how to handle large course structures.

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

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

The input schema already provides 100% coverage of both parameters with descriptions. The description adds little beyond the schema: it mentions 'optionally module items' which maps to include_items, but does not provide additional semantics like default behavior or format. Since schema coverage is high, the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists modules and optionally module items for a single Canvas course. It uses a specific verb and resource, but does not explicitly distinguish it from sibling tools like get_course_bundle or list_course_assignments. The scope 'in one Canvas course' narrows it, but no alternative is mentioned.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical use cases, or when to choose a different tool like get_course_bundle. The description simply states what it does, leaving the agent to infer usage context.

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

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

With no annotations provided, the description must disclose behavioral traits. It mentions the token-based visibility, which is useful. However, it omits details about pagination, sorting, response format (e.g., array of course objects), or any side effects (though listing is read-only). The description is functional 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, concise sentence that is front-loaded with the core purpose. It contains no redundant information and 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 tool with one optional parameter and no output schema, the description covers the essential purpose and scope. It could mention the return type (a list of courses) or potential pagination, but these are not strictly necessary for a simple list operation. The description is adequate, though 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?

Schema description coverage is 100% (the only parameter active_only is described in the schema). The description adds no additional meaning about parameters; it doesn't explain the effect of active_only or its default behavior beyond what the schema already states. Per the baseline for high schema coverage, this scores 3.

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

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

The description clearly states the tool lists Canvas courses visible to the configured token. This gives a specific verb (list), a clear resource (Canvas courses), and a scoping condition (visibility to the token), distinguishing it from sibling tools like get_course (singular) and list_course_files (specific resource type).

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

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

The description implies this is the entry point for getting all courses, while siblings like get_course are for specific courses. However, it does not explicitly state when to use this instead of alternatives or mention any exclusions. Given the clarity of the resource type (courses vs files/modules/etc.), the context is sufficient for an agent to infer usage.

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

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

With no annotations provided, the description must disclose behavioral traits. It only says 'List', implying read-only, but it does not state safety, authentication requirements, pagination, or what data is returned. The absence of an output schema amplifies the gap—the agent has no idea what the response contains.

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

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

The description is a single sentence that directly states the tool's purpose with no redundancy. The action and resource are front-loaded, making it immediately scannable.

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 one well-documented parameter, but the description provides no information about the return value or behavioral nuances. Since there is no output schema and no annotations, the description should describe what the list contains (e.g., video metadata, URLs), but it doesn't. This leaves the agent without crucial invocation context.

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

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

The schema fully describes course_id as 'Canvas course ID' with 100% coverage, so the baseline is 3. The description references the course implicitly ('for one Canvas course') but adds no extra semantic detail beyond what the schema already provides.

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

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

The description clearly states the action ('List') and the resource ('SJTU classroom videos') scoped to one Canvas course. This unambiguously differentiates it from sibling tools like list_course_files or list_course_modules, which target different resource types.

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

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

No guidance is provided about when to use this tool versus alternatives. It does not mention that video_status or get_video_info might be more appropriate for individual video details, nor does it exclude other list operations. Usage context is only implied by the resource name, 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?

With no annotations provided, the description carries the full transparency burden and does state two key behaviors: the operation is read-only and it returns redacted URLs. This is meaningful disclosure, though it leaves out details like pagination, empty results, or permissions.

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 tight sentences: the first states purpose, the second discloses behavior and output format. No filler 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?

For a simple two-parameter list tool, the description plus full schema coverage is nearly sufficient: it conveys scope, read-only safety, and output nature. Minor omissions such as zero-result behavior and pagination prevent a 5, but an agent can invoke this tool correctly from the provided text.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context for course_id via 'one Canvas course' but adds nothing about submitted_only beyond what the schema already says; it neither clarifies the default behavior nor the filtering 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 opens with a specific verb and resource ('List my submissions for one Canvas course'), immediately distinguishing this from sibling tools like list_course_assignments (course content) and get_my_submission (single submission). The additional phrase 'returns redacted URLs' further clarifies the tool's unique output.

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 when-to-use or alternative routing is provided. The description implies it is for viewing the current user's submissions in a course, but it never says when to choose this over get_my_submission or list_course_assignments, nor does it mention 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?

No annotations are provided, so the description carries the full burden. It discloses the key behavioral trait of not downloading files, which is critical for a safe preview operation. However, it does not explicitly state whether it is read-only, whether it requires authentication, or whether it has any side effects (e.g., creating temporary files). The description adds some value but misses potential side-effect disclosures.

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 words. It immediately conveys the core function (preview) and the key differentiator (without downloading). Excellent conciseness and structure.

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 two parameters and no output schema, the description gives a clear idea of what the tool returns (download size, statuses, local paths) and its non-destructive nature. It lacks details on return format or authentication, but given the tool's simplicity, it is fairly complete. The 'without downloading files' statement covers the main safety concern.

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 documents both parameters. The description does not add any additional meaning to course_id or output_dir beyond what the schema provides. It mentions 'local paths' in the output, which could relate to output_dir, but does not elaborate. Baseline 3 is appropriate since the schema 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 the tool's purpose: to preview download size, statuses, and local paths without actually downloading files. This distinguishes it from download_course_files and other download-related siblings by emphasizing the preview aspect. The verb 'preview' and resource 'course download' are specific and informative.

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

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

The description implies usage for planning or checking before downloading, but does not explicitly name alternative tools or conditions for when not to use it. It says 'without downloading files', which hints at a dry-run, but lacks explicit routing like 'use download_course_files when you are ready to download'. This is adequate but not fully explicit.

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

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

With no annotations, the description carries the behavioral burden. It does disclose an important safety property by promising 'only redacted auth metadata,' but it does not clarify whether the operation is read-only, whether it contacts an external SJTU service, or what error/performance behavior to expect.

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

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

A single sentence with no wasted words and no repetition of the title. The action, scope, and output constraint are all front-loaded in one clean clause.

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

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

For a simple one-parameter tool with no output schema, the description is nearly sufficient: input and general return type are stated. However, it omits deciding-when details and doesn't hint at the structure of the redacted metadata or failure modes, leaving some ambiguity for an agent choosing among many video-related siblings.

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

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

The schema already fully documents course_id as a Canvas course ID (100% coverage), so the description need only add context. It adds only that the tool works on 'one Canvas course,' which is marginal and does not change the baseline.

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

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

The description names a specific action ('Resolve'), a specific resource ('SJTU video auth'), and a scope ('one Canvas course'). It also states the output is 'only redacted auth metadata,' which differentiates it from sibling tools that list videos, return video info, or report video status.

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

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

There is no statement about when to prefer this tool over siblings such as video_status, get_video_info, or list_course_videos, and no prerequisites are mentioned. The phrase 'for one Canvas course' only limits scope; it does not guide an agent's decision about whether this tool is the right 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Return...' which implies a read operation but does not disclose output format, potential errors, authentication requirements, or side effects. For a status tool, this is minimal and leaves the agent guessing about the response structure.

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 words. It states the action immediately and stays concise, making it easy to parse quickly.

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

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

Given the absence of an output schema, the description should clarify what the returned 'integration flow' looks like. It does not specify whether it is a status enum, a list of implemented features, or a narrative. For a zero-param tool, this lack of detail is a significant gap, leaving an agent unsure of what to expect.

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 already covers everything. The baseline for 0 params is 4, and the description does not need to explain any parameters. It adds no extra meaning but none 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 clear verb-resource pair ('Return the implemented ... flow') and identifies the domain (SJTU video/subtitle/PPT integration). It distinguishes from siblings like get_video_info or get_video_subtitle by focusing on the overall flow rather than individual components. However, 'integration flow' is slightly ambiguous and could be more specific about what it represents.

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 does not mention that it is for checking overall integration status, nor does it reference any sibling tools or exclusion criteria. An agent is left to infer its purpose without explicit context.

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