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

There are no annotations, so the description carries the full burden of disclosing behavior. It clearly indicates a write operation ('Create'), but it does not mention permissions, whether the announcement is published immediately, what the response will be, or any side effects beyond creation.

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

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

The description is a single, concise sentence with no filler. It gets straight to the point and every word is relevant.

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

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

For a simple three-parameter creation tool with fully documented parameters, the description plus schema is nearly sufficient. However, the absence of any usage guidance or note about the created object's output leaves a minor completeness gap.

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

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

Schema description coverage is 100%, so the parameter names and descriptions already explain title, message, and course_id. The description adds only the course scoping and no deeper meaning about formats, constraints, or relationships between 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 uses a specific verb ('Create') and resource ('announcement') scoped to a course, making the tool's primary purpose clear. It distinguishes itself from listing-related siblings like list_announcements, though it does not explicitly differentiate itself from other create_* course 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?

No guidance is provided about when to use this tool versus alternatives such as list_announcements or create_discussion. The description implies its use for creating announcements but does not state exclusions, prerequisites, or context that would help an agent choose it confidently.

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 carry the behavioral burden. It only states that an assignment is created, and does not disclose effects like whether the assignment is initially unpublished, whether there are permission requirements, idempotency, or what happens on duplicate names. It is not misleading, but it is nearly silent.

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

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

One front-loaded sentence states the core action and resource with no waste. Every word earns its place; this is as concise as a purpose statement can be.

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

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

For a mutation tool with 7 parameters, 2 required, no annotations, and no output schema, a single purpose sentence is insufficient. It does not explain return behavior, creation side effects, or the meaning of optional fields beyond what the schema already states.

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 structured property descriptions already document every parameter. The description adds no parameter-level meaning beyond echoing course scope, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Create') and resource ('new assignment') with the Canvas course scope, so an agent can tell it from list, get, and update assignment tools. However, it does not explicitly differentiate it from sibling create_* tools like create_announcement or create_discussion, so it falls just short of a 5.

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

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

There is no guidance on when to choose this tool over alternatives such as update_assignment or list_assignments. The verb 'Create' implies one use case, but no prerequisites, exclusions, or alternative routing 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only restates the creation action. It does not mention required permissions, side effects, whether the event is published or draft, calendar ownership, or what happens on duplicate times.

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 text is brief but this is under-specification rather than concise completeness. One short sentence fails to provide front-loaded details about required fields, behavior, or response.

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

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

For a write tool with six parameters, three required fields, no output schema, and no annotations, 'Create a calendar event' is inadequate. The agent lacks information about required input semantics, call effects, and expected 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 input schema provides descriptions for all six parameters, including formats like ISO 8601 and an example context code. The description adds no parameter-level meaning, but the high schema coverage keeps this at 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 'Create a calendar event' is a near-verbatim restatement of the tool name and adds no distinguishing detail. It identifies the action and resource but does not differentiate this from other create tools or explain what kind of calendar event is involved.

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

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

There is no guidance on when to use this tool versus alternatives such as list_calendar_events or other create_* tools. No conditions, prerequisites, or exclusions are given, so the agent must infer usage entirely from the operation name.

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

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

With no annotations, the description carries the full behavioral burden, but 'Send a new message' only states the core action. It does not disclose side effects, permission requirements, whether a conversation is created, or what response the caller should 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?

The description is a single efficient sentence with no wasted words. It front-loads the primary action, though its brevity borders on under-specification.

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

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

For a write operation with no annotations and no output schema, the description is incomplete. It lacks usage context, behavioral details, and any indication of return values or side effects, leaving the agent with only the schema to work from.

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

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

Schema description coverage is 100%, with each parameter already described in the schema. The tool description adds no additional parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description 'Send a new message' clearly conveys a send/create action on a message resource, matching the tool name create_conversation. It is not a tautology, but it does not differentiate from siblings like create_announcement or create_discussion.

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

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

No guidance is provided about when to use this tool versus alternatives such as create_announcement or create_discussion. The description implies a messaging use case but offers no conditional context, prerequisites, or exclusions.

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

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

There are no annotations, so the description bears the full burden of behavioral disclosure. It only states the action ('Create a discussion topic') and provides no information about side effects, permissions, return values, or behavioral nuances. The write nature is implied but not elaborated.

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

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

The description is one concise, front-loaded sentence with no filler. It communicates the tool's core purpose efficiently, and all necessary parameter details live in the schema, making the brevity appropriate.

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

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

For a mutation tool with no annotations and no output schema, the description is minimal. It does not mention course context, publication defaults, expected return data, or any post-create behavior. The schema fills in parameter details, but the description alone leaves the tool's overall operational context thin.

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 semantics beyond the schema, but the schema already documents all five parameters, including defaults and the discussion_type enum, so no additional compensation is required.

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

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

The description states a specific verb and resource: 'Create a discussion topic.' It clearly conveys the core action and distinguishes it from sibling tools like create_announcement or create_calendar_event, though it does not explicitly differentiate from them.

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

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

The verb 'Create' implies the tool should be used when the agent needs to create a discussion topic, but there is no explicit guidance about when not to use it or which alternative to choose. The sibling list includes similar create tools, but the description alone gives no comparative 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 of explaining side effects, but it only restates the action. It does not disclose draft/publish behavior, permission requirements, whether existing pages can be overwritten, or what the tool returns after creation.

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, which is conciseness in a narrow sense. However, it is under-specified rather than efficiently informative, adding little beyond the tool name.

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

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

This is a mutation tool with four parameters and no output schema, yet the description provides no context about page visibility, course association, default published state, or expected result. An agent would have to infer most of the behavioral contract from parameter names alone.

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 input schema fully documents all parameters. The description adds no parameter-level meaning, but the high schema coverage justifies 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 specific action and resource: create a wiki page. It is clear enough to distinguish from sibling tools that create assignments, discussions, announcements, or calendar events, though it does not explicitly name any alternative.

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

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

No guidance is given about when to use this tool versus update_page, list_pages, or other create_* tools. There are no exclusions, prerequisites, or context clues beyond the basic action implied by the name.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Get details' clearly indicates a read-only lookup with no side effects, which is appropriate for the tool. It does not mention auth requirements or response specifics, but the risk profile is low for a simple get operation.

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

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

The description is a single concise sentence with no filler or redundant wording. It front-loads the action and resource, and every word earns its place.

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

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

For a low-complexity retrieval tool with two documented required parameters, the description is sufficient for an agent to call it correctly. It does not specify the output shape, but no output schema exists and 'details' is adequate. Mentioning how to discover assignment_id via list_assignments would be useful but is 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?

The input schema already documents both parameters with 100% coverage, so the description does not need to add parameter detail. It adds no semantic value beyond 'course ID' and 'assignment ID', so the baseline of 3 is appropriate.

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

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

States a specific verb ('Get') and resource ('Canvas assignment'), and the word 'specific' signals single-item retrieval, clearly distinguishing it from list_assignments. The core purpose is unambiguous and easy for an agent to match to a request for one assignment.

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

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

There is no explicit when-to-use guidance or named alternative. However, 'specific assignment' implies this tool is for retrieving one known assignment, contrasted with listing assignments. This is implied usage rather than 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 must carry the behavioral disclosure burden. 'Get' implies a read-only operation, but the description does not mention what happens for invalid IDs, permission requirements, rate limits, or whether a missing conversation returns an error or null. This is minimal transparency for a simple getter.

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 six-word sentence with no filler or redundant information. It is immediately front-loaded with the action and resource, making it easy to scan. Nothing could be removed without losing meaning.

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

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

For a tool with one well-documented parameter and no output schema, the description is minimally sufficient to allow a call attempt. However, it lacks any context about what a conversation contains, how it relates to sibling conversation tools, or what the return shape looks like. An agent could still call it correctly but without deeper situational awareness.

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 single parameter is already documented as 'Conversation ID'. The description adds no additional meaning about the parameter format, source, or acceptable values. With full schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly names a verb ('Get') and a resource ('a specific conversation'), making the basic purpose immediately understandable. It distinguishes itself from list_conversations by emphasizing specificity, but it does not explicitly mention that it operates by conversation ID or differentiate itself from other detail-fetching tools like get_discussion.

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

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

There is no guidance on when to use this tool versus alternatives such as list_conversations or get_course. The description implies that you use it when you want one specific conversation, but it does not state conditions, exclusions, or when a different tool would be more appropriate.

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 behavioral disclosure burden. It clearly indicates a read operation and describes the expected content, but it does not explicitly state that no changes are made, what happens for invalid IDs, or any permission requirements. 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?

A single, well-structured sentence that front-loads the action and resource, then lists the return-relevant details. There is no filler or redundancy.

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

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

For a simple read tool with one fully documented parameter, the description gives enough content detail for an agent to understand the expected result. It lacks explicit handling of error cases or permissions, but the low complexity and clear schema make it substantially 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 schema already fully documents course_id as 'The Canvas course ID'. The description does not add meaningful parameter-level detail beyond that, so it meets the baseline without exceeding 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 uses a specific verb and resource: 'Get detailed information about a specific Canvas course' and enriches it with concrete content fields (syllabus, term, teachers, student count). This clearly distinguishes it from siblings like list_courses and get_course_settings.

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

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

The phrase 'a specific Canvas course' implies it is for fetching one course by ID rather than listing courses, providing clear context. However, it does not explicitly name alternatives or state when not to use this tool, so it stops short of full guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether the operation is read-only, what events are included, result ordering, pagination, or any rate/access implications. This is too thin for an activity-stream endpoint.

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, direct sentence with no filler or redundancy. It is front-loaded with the key action and resource. It loses a point because its brevity omits useful behavioral context, but as an efficiency matter it is well-formed.

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

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

For a one-parameter tool, the schema covers the input contract. However, with no output schema and no annotations, the description leaves unclear what 'recent activity' contains, how far back it goes, and what the response looks like. This is minimally viable but incomplete.

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

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

Schema description coverage is 100% and the only parameter, course_id, is already documented as 'The ID of the course.' The description adds only the phrase 'for a course,' which maps naturally to the parameter without further semantic value.

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

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

The description clearly states the verb and resource: 'Get recent activity for a course.' This distinguishes it from course-detail tools like get_course and get_course_settings, though it doesn't explicitly name an alternative or describe what counts as activity.

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

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

The phrasing 'Get recent activity' implies when to use the tool, but there is no explicit guidance about when not to use it or which sibling tool to prefer. An agent can infer the intended use, but exclusions and alternatives are absent.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Get' clearly implies a read-only operation, and the scope is stated, but the description does not mention what settings are returned, access requirements, or error behavior.

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

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

The description is a single clear sentence with no filler or unnecessary detail. It is concise and front-loaded, though it could have included a bit more context without becoming bloated.

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

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

For a simple getter with one fully documented parameter, the description is minimally viable. However, it does not explain what 'settings' includes or how the response will look, and it lacks differentiation from get_course, leaving some ambiguity for an agent.

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

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

The schema already provides 100% description coverage for the single course_id parameter. The description adds no parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description names a specific verb ('Get'), a resource ('settings'), and a scope ('specific Canvas course'). It clearly identifies what the tool does, though it does not explicitly differentiate it from sibling tools like get_course or list_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?

No guidance is given about when to use this tool instead of similar siblings such as get_course or list_courses. The intended usage is only implied by the phrase 'for a specific Canvas course.'

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 are absent, so the description must carry the behavioral disclosure burden. 'Get' implies a read operation, but the description does not state the return shape, whether associated entries are included, or what permission or error behavior applies.

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

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

One short, direct sentence with no filler. It is efficiently communicative, though a short clause about scope or return value could make it slightly more useful.

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 2-parameter tool, and the schema supplies the required inputs. However, without an output schema or behavioral detail, the description leaves gaps about what the result contains, especially given the availability of list_discussion_entries as a related tool.

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

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

The schema covers both parameters with basic descriptions at 100% coverage, and the description adds no extra semantic detail about ID formats or how course_id and topic_id relate. Baseline 3 is appropriate.

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

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

The description uses a concrete verb ('Get') and names the resource ('specific discussion topic'). The singular phrasing distinguishes it from list_discussions and create_discussion, though it could more explicitly clarify what a 'discussion topic' includes.

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

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

No guidance is provided about when to use this tool versus alternatives such as list_discussions or list_discussion_entries. An agent must infer the correct usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Get file details.' It does not reveal whether it returns metadata or content, what permissions are needed, or what side effects, if any, exist. The read-only nature is implied by 'Get' but not elaborated.

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

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

The description is only three words and contains no fluff or redundancy. It is appropriately short for a simple getter, though it could have used a bit more specificity without bloating.

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 getter, the description is minimally adequate, but it lacks an output schema and does not clarify what 'details' means. An agent could not confidently distinguish this from list_files or know what kind of response 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?

Schema description coverage is 100%, so the lone parameter is documented in the schema. However, the parameter description 'File ID' is tautological and the tool description adds no further semantic context. Baseline 3 is appropriate.

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

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

The description 'Get file details' uses a specific verb and resource, clearly identifying it as a single-file retrieval operation. It distinguishes itself from the sibling list_files by contrasting 'get' with 'list', though 'details' is somewhat vague.

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 list_files or list_folders. The description does not state that this is for fetching a single known file by ID, nor does it mention any alternative tools or exclusions.

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

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

No annotations are provided, so the description shoulders the burden of behavioral disclosure. It only indicates a read-style operation ('Get'), but does not mention errors, auth requirements, return value shape, or side effects, leaving important behavior opaque.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though it offers so little detail that it reads more like a label than a full tool explanation.

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 get-by-ID tool with two fully documented required parameters, this is minimally adequate. However, with no annotations and no output schema, it omits useful context about the returned module and how to choose between get_module and list_modules.

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 course_id and module_id already documented as 'Course ID' and 'Module ID'. The description adds no parameter-level insight, but the schema fully covers the parameters, so the baseline 3 applies.

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

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

The description states a specific verb ('Get') and resource ('a specific module'), making the tool's purpose immediately clear. The word 'specific' weakly distinguishes it from sibling list_modules, but it does not explicitly contrast with related listing tools.

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

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

There is no guidance on when to use get_module versus list_modules or list_module_items. No alternatives, prerequisites, or exclusions are mentioned, so the agent must infer usage context solely from the tool name.

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

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

There are no annotations, and the description only restates the operation; it does not disclose read-only guarantees, required permissions, response format, or error behavior. The word 'Get' implies a read operation, but that is not explicit behavioral disclosure.

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

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

The description is a single front-loaded sentence with no wasted words, which is appropriately concise for a simple getter. It loses a point only because it offers no additional scoping or routing context that would make the line more informative.

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 two well-documented parameters and no output schema, the description is minimally usable: an agent can infer that course_id and url_or_id identify the page to retrieve. However, without annotations or any mention of return values or error cases, the definition is thin and relies entirely on the schema for 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 input schema already documents both required parameters with concise descriptions ('Course ID' and 'Page URL slug or ID'), giving 100% schema coverage. The description adds no parameter semantics beyond the schema, so the baseline 3 applies.

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

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

The description identifies a specific verb ('Get') and resource ('wiki page'), making the tool's role as a single-page reader clear and distinct from list_pages or create_page. It does not name sibling tools or mention the course scope, which keeps it from a 5.

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

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

No guidance is given on when to choose this tool over sibling tools such as list_pages or get_file, nor are any exclusions or prerequisites stated. The intended use is only implied by the verb and resource.

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 says 'Get', which implies a read-only operation, but it does not mention permissions, possible errors, whether a submission may be absent, or what the response contains.

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

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

The description is a single, clear sentence with no wasted words. It front-loads the verb and resource, keeping the definition easy to scan without unnecessary elaboration.

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

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

For a low-complexity getter with three required parameters, the description is minimally sufficient. However, with no annotations and no output schema, it leaves gaps such as return format, possible null submissions, and permission requirements.

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

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

The schema covers 100% of the parameters, but the descriptions are minimal ('The user/student ID', etc.) and add little beyond the property names. The tool description itself adds no further semantic guidance about parameter formats or relationships, so a baseline 3 is appropriate.

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

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

The description clearly states a specific action (get) and resource (a student submission for a Canvas assignment). The word 'specific' helps differentiate it from list_submissions, though it does not explicitly name or contrast with sibling tools.

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

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

No guidance is given about when to use get_submission versus list_submissions or grade_submission. The intended use is implied by 'specific', but there are no explicit conditions or alternatives, so the agent must infer based on the schema 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?

There are no annotations, so the description carries the full behavioral burden. 'Get' conveys a non-destructive read, but the description does not mention permissions, scoping, return contents, or failure behavior, leaving some ambiguity.

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

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

A single, direct sentence with no filler. The action and target are front-loaded, and every word contributes meaning.

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

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

The definition is minimally viable for a one-parameter read tool, but the lack of output schema details and the existence of a nearly identical sibling tool leave some gaps. It is adequate, not complete.

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

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

The schema already documents user_id with 100% coverage, so the description adds little beyond restating that the tool targets a specific user. This meets the baseline for a well-covered schema.

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

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

The description clearly identifies a read operation on a single user resource and mentions what is being retrieved (a user's profile). It does not distinguish get_user from the similarly named sibling get_user_profile, so it misses the top tier.

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 for when to use this tool versus get_user_profile, list_course_users, list_students, or get_user_enrollments. An agent has to guess which sibling matches the intent.

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 transparency burden. 'List' implies a read operation and no destructive behavior, but the description does not disclose pagination behavior, default user scoping beyond the schema, or any side effects. The transparency is minimal and mostly relies on the schema's parameter descriptions.

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

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

The description is a single short sentence with no wasted words. It is succinct and front-loaded with the core operation. It lacks richer structure or additional context, but for its brevity it is still 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 no annotations, the description is thin for a tool with three optional parameters and at least one ambiguous sibling ('list_enrollments'). It does not explain what enrollment data is returned, how pagination is signaled, or how this differs from similar list operations. The description is too minimal to fully contextualize the tool.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters with meaningful descriptions. The description itself adds no parameter-level semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'List enrollments for a user.' It clearly identifies the main operation and the target resource. However, it does not differentiate this tool from the sibling 'list_enrollments', so an agent may not know which to choose without further inspection.

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. Given the existence of 'list_enrollments' as a sibling, the absence of any selection criteria or contrasting context is a notable gap. An agent is left to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Get' clearly indicates a read operation, but the description does not mention authentication requirements, the shape of the returned profile, or any other behavioral context. For a zero-parameter read-only tool this is minimally adequate but not rich.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every word contributes to identifying the operation and its scope.

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

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

The tool has no parameters, no output schema, and no annotations, so the description is nearly sufficient for an agent to select and invoke it correctly. It could be more complete by describing what 'profile' contains or what the response looks like, but for a simple self-explanatory getter this is adequate.

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

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

The input schema has zero parameters, so there is no parameter documentation burden. The baseline of 4 applies when no parameters need explaining, and the description introduces no confusing parameter-related information.

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

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

The description names a specific verb ('get'), a resource ('the current user's profile'), and adds the scope qualifier 'current user's', which helps distinguish it from sibling tools like get_user. It stops short of explicitly contrasting with get_user, but the core purpose is unambiguous.

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

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

No guidance is provided about when to use this tool versus alternatives such as get_user or get_user_enrollments. The 'current user' wording implies a use case, but the description never states exclusions, prerequisites, or when another sibling would be more appropriate.

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 says 'Grade' without revealing whether an existing grade is overwritten, whether the grade is posted to the student, what permissions are needed, or what the response contains. For a state-changing action, this is a significant gap.

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

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

The description is a single, direct sentence with no filler or redundancy. It is concise and easily parsed, though the brevity leaves room for missing behavioral and usage context.

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

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

For a write operation with no annotations, no output schema, and no usage guidance, this description is incomplete. An agent would need to infer important context such as side effects, prerequisites, and what happens after grading. The schema fully documents parameters but does not compensate for the missing operational context.

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

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

The input schema has 100% description coverage for all five parameters, so the schema already explains course_id, assignment_id, user_id, grade, and comment. The description itself adds no additional parameter-level meaning, but because the schema is complete, the baseline of 3 is appropriate.

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

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

The description states a clear action ('Grade') on a specific resource ('a student submission for a Canvas assignment'), so an agent can understand the core purpose. It does not differentiate the tool from siblings like list_submissions or get_submission, but the verb and object make the intended operation fairly unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives, and no prerequisites such as verifying the submission exists or the student is enrolled. Context of use must be inferred entirely from the tool name and schema.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the action and resource, without mentioning read-only behavior, pagination, date filtering semantics, ordering, or side effects. The verb 'List' implies a read operation, but the description adds no meaningful behavioral detail beyond that.

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

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

The description is a single, concise sentence that front-loads the core action and resource. It is not verbose, though its brevity leaves gaps captured in other dimensions.

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

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

The description is minimally viable for a simple list operation, especially since the schema documents all parameters and course_id is the only required one. However, it lacks return-value context, usage guidance, and behavioral details like date-range handling or pagination, so it is not fully complete.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the input schema. The description adds little parameter meaning beyond 'for a course,' which loosely maps to course_id, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('List') with a clear resource ('announcements') and scope ('for a course'), making the primary function unambiguous. It is clearly distinguishable from siblings such as list_courses and create_announcement because both the action and resource are named.

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

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

The description gives no guidance on when to use this tool versus alternatives like create_announcement, list_discussions, or get_course_activity_stream. No usage context, exclusions, or prerequisites 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, but it does not disclose pagination behavior, response shape, or any filtering/workflow-state defaults, so an agent cannot anticipate the tool's behavior beyond the bare action.

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

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

A single front-loaded sentence with no filler; every word contributes to identifying the action, resource, and scope. It is appropriately sized for a straightforward list 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 combination of the sentence and the fully documented schema is enough for a basic call, but the tool has no output schema and no annotations, and the description does not explain return values or pagination behavior. It is minimally viable rather than fully complete.

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

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

Schema description coverage is 100%, so the input schema already documents course_id, order_by, and per_page. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description names a specific verb ('List') and the resource ('assignments') scoped to a Canvas course, so an agent can tell it is a bulk-read tool rather than get_assignment or create_assignment. It falls short of a 5 because it does not explicitly scope the list (e.g., all assignments vs. filtered) or contrast with the sibling single-assignment 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?

There is no guidance about when to choose this over get_assignment, list_submissions, or other sibling tools, nor any mention of prerequisites such as course access. The plural name and 'list' verb imply usage, but the description leaves the selection criteria 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the high-level operation. It does not mention pagination behavior, whether results are filtered by date or context, authentication requirements, or any side effects, so the agent cannot predict the tool's behavior beyond 'listing'.

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

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

The description is short and front-loaded, but it is under-specified rather than efficiently concise: it repeats the tool name and provides no additional structure or qualifiers. It reads as a stub rather than a deliberate, information-dense summary.

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 four optional parameters and no output schema, so the description needs to explain what events are listed, how date/context filters interact, and what the response looks like. None of that is present, leaving significant gaps for an agent trying to invoke the tool correctly.

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

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

All four parameters already have descriptions in the input schema, including ISO date formats, the per_page default, and comma-separated context codes, so schema coverage is 100%. The description adds no parameter semantics, but it does not need to compensate for schema gaps; a baseline of 3 is appropriate.

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

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

The description 'List calendar events' uses a clear verb and resource, so an agent knows it returns calendar events rather than creating or updating them. However, it is essentially a restatement of the tool name and gives no scope information (whose events, what time range), making it only vaguely 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?

There is no guidance on when to use this tool versus alternatives such as create_calendar_event or other list tools. The context signals include no conditions or exclusions, so the agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It conveys a read-only listing operation scoped to the current user, which implies an authorization boundary, but it does not mention pagination behavior, ordering, or response shape, 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?

The description is a single concise sentence with no filler or redundancy. It front-loads the verb and resource, making the tool's purpose immediately clear.

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 only two optional parameters, the description is minimally adequate: it names the operation and scope, and the schema documents the parameters. However, the absence of an output schema and any behavioral notes about pagination or return content leaves some ambiguity about what exactly will be returned.

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 both 'scope' and 'per_page' are already documented in the schema with meaningful descriptions. The tool description adds no additional parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the action ('List'), the resource ('conversations'), and the scope ('for the current user'). This distinguishes it from sibling tools like get_conversation and create_conversation even without naming them.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_conversation for a single conversation or create_conversation for starting one. There are no exclusions, prerequisites, or context signals to help an agent choose correctly.

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 the core behavior: it lists all courses for the current user and supports optional filters. However, it does not mention pagination behavior, response shape, whether deleted courses can appear, or any authentication or permissions expectations.

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

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

The description is a single, efficient sentence that front-loads the primary function before mentioning optional filters. There is no redundant wording or unnecessary qualification.

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

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

The description adequately covers the basic list-and-filter use case, but it omits any reference to sibling tools like search_courses for broader course discovery, and it does not clarify returned data structure or pagination. Given there is no output schema, a bit more context about what the response contains would make it more complete.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description simply restates that filtering by enrollment type and course state is possible, adding no semantic detail beyond what the schema provides.

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

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

The description clearly states a specific action ('List all courses') and a well-defined scope ('for the current user'), with optional filtering by enrollment type and course state. It distinguishes itself from single-course tools like get_course, though it does not explicitly contrast with search_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 when to use this tool: when the user needs their own courses and may want to filter them. However, it gives no explicit guidance about alternatives such as search_courses, get_course, or list_enrollments, and does not state when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only the basic listing action and says nothing about pagination behavior, whether enrollment_type filters the returned users, ordering, or what the response contains. It is not misleading, but it adds no behavioral context beyond the tool name.

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 and is immediately understandable. It is appropriately concise, though it could have included a short differentiating clause without becoming bloated.

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 sibling list, the description is not complete enough for an agent to reliably select this tool over list_students or list_enrollments. It also lacks any behavioral or output context, and the absence of an output schema means the agent gets no return-shape information.

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 input schema already documents all three parameters. The description adds no real semantic detail beyond what course_id, per_page, and enrollment_type already convey, so the baseline score of 3 is appropriate.

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

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

The description states a clear action and resource: listing users scoped to a course. It is not vague, but it does not differentiate itself from siblings like list_students or list_enrollments, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus list_students, list_enrollments, or get_user_enrollments. The only usage signal is implicit in the optional enrollment_type filter, which is not explained in the description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool lists replies in a discussion; it does not mention read-only semantics, pagination behavior, ordering, whether nested replies are included, or any other side effects.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word contributes to the meaning, with 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 list tool with fully documented parameters, the description is minimally adequate: it names the purpose and scope, and the schema covers the inputs. However, with no output schema and no annotations, an agent still lacks information about response format, pagination defaults, and when to choose this tool over related discussion tools.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds slight context by clarifying that entries are 'replies', which gives topic_id more meaning, but it does not add substantial parameter-level details beyond the schema.

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

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

The description uses a specific verb ('List') and resource ('entries (replies)') and qualifies the scope with 'in a discussion'. It clearly distinguishes the action from related tools like list_discussions or get_discussion, though it does not name those alternatives explicitly.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_discussions or get_discussion. There are no exclusions, preconditions, or context signals that would help an agent decide between sibling tools.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, but the description adds no behavioral context such as whether full discussion entries are included, how ordering and pagination behave, or what happens for 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 short sentence with no filler, making it easy to scan. It is concise, though somewhat at the expense of additional useful context.

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

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

For a simple list tool, the description plus schema is minimally sufficient: the agent knows the required course_id and available ordering/pagination options. However, it lacks routing cues to related discussion tools and any statement about the response shape, which matters because there is no 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?

Schema description coverage is 100%, so course_id, order_by, and per_page are already documented. The description adds no meaningful parameter detail beyond the 'in a course' scoping that maps to course_id.

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'), resource ('discussion topics'), and scope ('in a course'), making the core purpose clear. However, it does not distinguish this tool from sibling tools like get_discussion or list_discussion_entries.

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

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

No guidance is provided about when to use this tool versus alternatives such as list_discussion_entries or get_discussion. The intended use is implied by the description, but no exclusions, prerequisites, or alternative routing are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the tool's name and gives no information about read-only behavior, pagination, default enrollment types, response shape, or required permissions. The per_page parameter implies pagination, but the description does not confirm any behavioral 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 a single, efficient sentence with no redundant wording or filler. It is front-loaded and easy to parse. It is sparse, but for conciseness it earns a solid score.

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

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

The description is too minimal to be contextually complete. With no annotations and no output schema, it does not clarify the return format, pagination behavior, or the difference from sibling tools like get_user_enrollments and list_students. The schema covers parameters, but the description leaves the agent without enough context for correct invocation and result interpretation.

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

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

Schema description coverage is 100%, so all parameters are already documented with meaningful descriptions in the input schema. The description adds no additional parameter-level semantics beyond what the schema provides, matching the baseline expectation.

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

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

The description uses a specific verb and resource: 'List enrollments in a course.' It is clear and unambiguous about the core action, but it does not differentiate itself from sibling tools such as get_user_enrollments or list_course_users, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention that this tool is for course-scoped enrollment listings as opposed to user-scoped listings, nor does it provide any context for choosing it over list_students or list_course_users.

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 says 'List files in a course' and does not mention read-only behavior, pagination behavior, sorting defaults, or what information is returned. The verb 'List' implies a non-destructive operation, but no explicit behavioral context is provided.

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

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

The description is a single concise sentence with no filler or redundancy. It front-loads the action and scope, though it is too sparse to fully support the other dimensions.

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 well-documented parameters, this is minimally viable: the agent can identify course_id is needed and optional filters exist. However, with no output schema and no annotations, it lacks usage differentiation and behavioral detail, so the completeness is adequate but thin.

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

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

Schema description coverage is 100%, so the schema already documents course_id, sort, per_page, and search_term. The description adds no meaning beyond the schema except tying the action to a course context.

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

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

The description states a clear verb and resource: 'List files in a course.' It identifies the core action and scope, though it does not explicitly differentiate from siblings like get_file or list_folders.

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

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

There is no guidance on when to use this tool versus alternatives such as get_file or list_folders. No prerequisites, exclusions, or context are given, so an agent must infer when this is the right choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the scope ('in a course') and adds no detail about return format, pagination, ordering, or whether only top-level folders are returned. It offers little beyond what the tool name already 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 five-word sentence with no filler, and the core action and scope are front-loaded. It is appropriately sized for the simplicity of the operation.

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

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

For a simple one-parameter list operation this description is minimally viable, but the absence of annotations, output schema, and any note about folder hierarchy or pagination leaves some context gaps. The abundance of sibling list tools also makes a bit more contextual guidance valuable.

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

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

The schema already documents course_id with a description, so schema coverage is 100%. The tool description adds no additional meaning for the parameter, but it does not need to compensate for any schema gap.

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

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

The description uses a specific verb ('List') and resource ('folders') with a clear scope ('in a course'), making the operation unambiguous. It distinguishes from sibling tools like list_files or list_courses without requiring schema inspection.

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 a course' implies the tool is for retrieving folders within a specific course context, but no explicit when-to-use or when-not-to-use guidance is given. It does not mention alternatives or conditions for choosing a different list tool.

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

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

With no annotations provided, the description carries the full burden of behavioral transparency. The verb 'List' implies a read-only operation, but the description does not mention pagination behavior, result format, or any other operational details. It is minimally adequate but not rich.

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

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

The description is a single clear sentence with no filler or redundant information. It is concise and front-loaded, though it could have used the available space to add more useful context.

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

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

For a simple listing operation, the description is arguably sufficient to invoke the tool with the required IDs, and the schema covers all parameters. However, without an output schema, the description does not clarify what kind of items are returned or what response shape to expect, leaving some ambiguity.

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 parameters are already documented in the schema. The description adds no additional meaning about course_id, module_id, or per_page beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the verb 'List' and the resource 'items in a module', making the tool's function obvious. It does not explicitly differentiate itself from siblings like list_modules or get_module, but the resource is distinct enough that confusion is unlikely.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_modules, get_module, or other list tools. There are no explicit contexts, exclusions, or references to sibling tools that would help an agent select among them.

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 is the sole source of behavioral context. It conveys that the call is a read-only enumeration, but it does not disclose pagination behavior, ordering, response contents, or caveats; given the per_page parameter and no output schema, this is a meaningful gap.

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

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

The single-sentence description is brief, front-loaded, and free of filler. It is appropriately concise for a straightforward list tool, though the brevity doubles as underspecification rather than deliberate efficiency.

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

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

For a low-complexity list operation with fully documented parameters, this is nearly sufficient: an agent knows the resource and scope. However, the lack of annotations and output schema means the return shape and pagination behavior are left unstated, leaving a moderate completeness gap.

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

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

The input schema already documents both parameters (course_id and per_page) with 100% coverage, so the description adds no parameter detail. The baseline of 3 applies because the schema handles the heavy lifting and the description does not mislead.

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?

"List modules in a course" names a specific action and resource with course scope, so an agent can tell it is a collection-read operation. It is clear enough at a glance, but the description does not explicitly contrast it with closely related siblings like get_module or list_module_items, so it falls just short of full differentiation.

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

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

The description provides no guidance on when to choose this tool over alternatives; it only states the operation. With sibling tools such as get_module and list_module_items nearby, an agent receives no routing help and must infer the right use case from the name alone.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'list' without revealing whether the result is paginated, what fields each page object contains, whether it returns full content, or how course scoping behaves. The description adds no meaningful behavioral traits beyond the literal meaning of the name.

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

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

The description is a single, short sentence that front-loads the action ('List') and contains no fluff. It is concise, though arguably could expand slightly to include output or usage context. Still, every word earns its place.

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

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

For a simple list operation with three well-documented parameters, the description is minimally viable: it identifies the resource and scope. However, with no output schema or annotation, it does not describe the return shape, pagination behavior, or any additional course requirements. The lack of return information is a notable gap for an agent consuming 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 coverage is 100% — every parameter (sort, per_page, course_id) has a description in the schema. The tool description itself adds no parameter-level detail, but the high schema coverage sets a baseline of 3. The description does provide the context that pages are listed per course, which complements course_id slightly.

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

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

Description states a specific verb ('List'), a specific resource ('wiki pages'), and a scope ('in a course'). The plural 'pages' clearly distinguishes it from sibling tools like get_page, and the verb 'list' separates it from create_page/update_page. No ambiguity about what operation is performed.

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

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

No guidance is provided about when to use this tool versus get_page or other list tools. The description only states what it does, not when an agent should choose it over alternatives or any conditions/exclusions. The agent must infer usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden. It does disclose output scope (students only, with email and enrollment details) and implies a read-only listing, but it does not mention pagination sensitivity, enrollment status filters, or that 'all students' may require multiple pages.

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. The verb and resource are front-loaded, and the included fields add useful value without bloat.

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

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

The description is adequate for a simple listing tool: the required course_id is clear and return fields are partially described. However, with no output schema and no mention of pagination behavior or selection among similar sibling tools, an agent might not know how to fully retrieve all students or choose this over list_enrollments.

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

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

The input schema already documents both course_id and per_page with 100% coverage, so the baseline is 3. The description adds no additional meaning beyond what the schema provides, such as how per_page interacts with the 'all students' claim.

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 students in a specific Canvas course and names the included fields (email, enrollment details). This distinguishes it from course-level tools like list_courses and list_assignments, though it does not explicitly differentiate from closely related siblings like list_course_users or list_enrollments.

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 list_students versus list_course_users, list_enrollments, or get_user_enrollments. The description implies the intended context, but it does not state exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'List submissions' and does not mention pagination behavior (despite the per_page parameter), return shape, ordering, or any permissions needed. It conveys a read-only operation but little else.

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 is efficient and easy to parse, though extremely terse.

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 required parameters are well-documented in the schema, and the operation is simple enough to be minimally viable. But with no output schema and no mention of pagination or return format, an agent lacks some context that would improve correct invocation and interpretation of results.

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 course_id, assignment_id, and per_page all described in the schema. The description adds no new parameter meaning beyond echoing the assignment context.

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 ('submissions for a Canvas assignment'), and the plural 'submissions' clearly distinguishes it from the sibling get_submission (singular). It is unambiguous about what the tool does.

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

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

The intended use is implied by the name and verb: when you need to list multiple submissions for an assignment. However, it does not explicitly compare against alternatives like get_submission or grade_submission, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It only restates the operation at a high level and omits output shape, pagination, ordering, or side-effect/safety confirmation.

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

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

The description is a single concise sentence with no filler. The scoping qualifier 'current user's' adds useful specificity without extra length.

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?

Adequate for a simple no-parameter list tool, but with no annotations and no output schema, it leaves behavioral expectations such as response format, pagination, and ordering unspecified. Still, the operation is simple enough for an agent to invoke correctly.

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

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

The tool has zero parameters, so the description does not need additional parameter detail. This is the appropriate baseline for a parameterless tool.

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

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

Description states a specific verb ('List') and resource ('current user's todo items'), with clear scoping. It is distinguishable from sibling list_* tools that target courses, assignments, files, etc.

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

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

No guidance is given about when to use this tool versus sibling list tools or alternative ways to retrieve todo data. There are no exclusions, conditions, or alternative tool mentions.

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. The word 'search' implies a read-only operation and the per_page parameter hints at pagination, but the description does not explicitly state that it returns matching courses, how results are ordered, or any access/rate expectations. It is not misleading, but it adds only minimal behavioral depth.

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

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

The description is a single short sentence that conveys the core purpose with no filler. It is front-loaded and easy to parse, earning its place despite omitting some useful contextual 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 two-parameter read-only search tool, the description is minimally sufficient and the schema fully documents inputs. However, with no output schema and no annotations, the agent is left to infer the return shape and precise search semantics, and it receives no guidance on when to prefer this tool over 'list_courses'.

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

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

The input schema has 100% description coverage for both parameters, including defaults and descriptions. The tool description adds no additional parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description names a concrete action ('search') and resource ('courses') and clarifies scope ('across the account'). It is clearly distinct from 'get_course' and 'list_courses' in intent, but it does not explicitly describe what the search matches (e.g., name/code) or name the sibling it is meant to replace, making sibling differentiation only implicit.

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

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

There is no explicit statement about when to use this tool over 'list_courses' or when not to use it. The verb 'search' implies a lookup-by-term use case, but alternatives, exclusions, and recommended selection criteria are left entirely unstated.

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, but it only repeats the meaning of the verb 'Update'. It does not state whether updates are partial or full replacements, whether unspecified fields are preserved, what happens if the assignment does not exist, or any permission/error implications.

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

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

The description is a single sentence with no filler words. It front-loads the action and resource and is easy to scan, which aligns well with the conciseness and structure criterion.

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

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

For a mutating tool with no annotations, no output schema, and seven parameters, the description is too sparse to be fully contextual. It omits update semantics, return value expectations, and failure behavior; the schema covers parameters but not the behavioral context needed for safe invocation.

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

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

All seven parameters have descriptions in the input schema, so the schema already carries the parameter meaning. The description adds no parameter-level detail, but the 100% schema coverage justifies 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 clearly states the action (Update) and the resource (an existing assignment in a Canvas course), making its core purpose immediately understandable. The word 'existing' helps distinguish it from create_assignment, though it does not detail the specific updatable attributes beyond what the schema shows.

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: an assignment already exists and needs modification. However, it provides no explicit guidance about when not to use it, no mention of alternatives like create_assignment or get_assignment, and no prerequisites or preconditions.

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. 'Update' only indicates mutation; it does not disclose side effects, whether the page must already exist, permission requirements, or impact on publishing state. The description adds little beyond the operation itself.

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

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

The description is a single short sentence with no filler or redundancy. It is front-loaded and easy to parse. However, it is so terse that it sacrifices useful context, keeping it from a 5.

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

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

For a mutation tool with no annotations, no output schema, and one of many sibling operations, this description is incomplete. It gives no usage context, no behavior beyond 'update', and no indication of mutating side effects. The schema covers parameter meaning, but the operational context an agent needs is missing.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no extra meaning about how course_id, url_or_id, body, title, or published interact. Baseline 3 is appropriate because 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 a specific verb ('Update') and resource ('wiki page'), so an agent can tell this apart from get_page, list_pages, and create_page. It is brief but not misleading. No additional scope or field information is given, but the core purpose is unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention that this tool is for existing pages, nor does it contrast with create_page for new pages or get_page for viewing. The agent must infer usage entirely from the name and schema.

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