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

With no annotations provided, the description carries the full burden, and it does disclose the output shape (metadata plus plain text, to-dos rendered as [ ] / [x]), which is real added value. However it says nothing about read-only safety, permission/auth requirements, or what happens when content exceeds max_chars.

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 parenthetical sentence that front-loads the action and then the return format. Nothing is wasted and nothing is buried.

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

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

For a simple two-parameter read tool with no output schema, the description covers the essentials of what comes back, but omits the truncation semantics of max_chars and any indication of failure modes, which are the two things an agent most needs before calling it.

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

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

Schema description coverage is 0% for both parameters, so the description needed to compensate and does not: page_id is never explained and max_chars, the truncation control, is entirely unaddressed, leaving the agent to guess whether output is cut off silently.

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

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

States a specific verb and resource ('Read a page') and goes further by naming the return payload: metadata plus plain-text content with to-do markers. It contrasts implicitly with the onenote_list_pages and onenote_search_pages siblings by framing this as a single-page read, though it never names those alternatives.

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

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

Usage is only implied by the verb and by the required page_id in the schema; there is no statement of when to prefer this over onenote_search_pages or onenote_list_pages, and no prerequisites or error conditions 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 disclosure burden. It does add real value by enumerating which notebook sources are included (owned, shared, group team notebooks), which is behavioral context beyond the name, but it says nothing about read-only safety, result ordering, or size of the result set.

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

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

A single sentence with zero filler, front-loading the verb and resource and putting the scope enumeration immediately after. Nothing in it is redundant with the title or schema.

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

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

For a zero-parameter list tool with an output schema that documents the return shape, the description is nearly complete. The only residual gaps are whether results are paged or ordered, which an agent may still need to know.

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 takes zero parameters, so the baseline is 4; the schema fully covers the (empty) input and there is nothing further for the description to disambiguate.

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

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

States a specific verb ('List') and resource ('OneNote notebooks') and scopes the result set with a parenthetical covering owned, shared, and group team notebooks. This clearly separates it from siblings like onenote_list_sections and onenote_list_pages, though it never names those siblings 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?

Usage is only implied: an agent can infer this is the entry point for browsing notebooks before drilling into sections or pages. There is no explicit when-to-use statement, no mention of when to prefer onenote_search_pages, and no prerequisites (e.g., sign-in or permissions) are stated.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does reveal that omitting section_id switches to a cross-notebook 'most recently modified' mode, which is genuinely useful behavioral context, but it says nothing about ordering, recency windows, pagination, or how many results a 'recent pages' call returns.

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

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

A single sentence, front-loaded with the primary section-scoped use case and the fallback mode immediately after. No filler.

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

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

An output schema exists, so return values need not be explained. For a 2-parameter read tool with no annotations and zero schema descriptions, though, the description should say more about the limit parameter and result ordering; the 'most recently modified' claim is asserted without any definition.

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

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

Schema description coverage is 0%, so the description needs to compensate and only partly does. It implies section_id's meaning and its optional alternative mode, but the 'top' parameter is never mentioned — no default of 20, no maximum, no note on what it limits in the cross-notebook mode versus the section mode.

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 gives a specific verb (List) and resource (pages) plus a two-mode scope: within a section, or the user's recently modified pages across all notebooks. That cleanly separates it from onenote_get_page (single page) and largely from onenote_search_pages, though the search sibling is never named as a contrast point.

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 two modes are described, which implicitly tells the agent when each applies, but the trigger conditions are left to inference. It never states when to choose this over onenote_search_pages, nor what the default behavior is when no section_id is supplied.

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, and it does disclose two useful behaviors: results include nested section groups, and omitting a notebook targets all notebooks. It does not state that this is a read-only operation, nor anything about pagination or result volume.

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; the scope distinction and the nested-group behavior are packed in without redundancy.

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

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

For a one-optional-parameter listing tool with an output schema covering return values, the description supplies the key facts an agent needs: the two scopes and the nested-group inclusion. Only minor gaps remain (identifier format, read-only nature).

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 0% and the sole parameter has no description, so the description must compensate — and it does, conveying that notebook_id scopes to one notebook while its absence means all notebooks. It stops short of giving the identifier's format or where to obtain 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 names a specific verb and resource ("List sections") and clarifies the two possible scopes: one notebook or all notebooks. It does not explicitly differentiate itself from siblings like onenote_list_pages or onenote_list_notebooks, but the resource being listed is unambiguous.

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

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

The phrase "either in one notebook or across all notebooks" implies how scope is selected, which hints at usage, but there is no explicit when-to-use guidance or named alternative (e.g., use onenote_list_notebooks first to find a notebook_id). Usage must be inferred.

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 usefully states that matching is case-insensitive and title-only, but it omits the `top` result limit, ordering behavior, and any authorization or rate-limit context. The output schema covers return values, but key search-behavior details remain unstated.

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

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

The description is two short sentences with no filler and is front-loaded with the primary behavior. The exclusion is placed immediately after, so every sentence earns its place.

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

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

For a two-parameter search tool, the description covers the main query behavior and excludes body search, and the output schema handles return values. However, with no annotations and no schema descriptions, leaving `top` entirely undocumented makes the definition incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the `query` text is matched against page titles case-insensitively, but it never mentions the `top` parameter or its default of 20. One of the two parameters is left unexplained beyond its name.

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

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

The description states a specific verb and resource: find pages whose title contains text. It also clarifies the search scope by excluding page bodies, making the core behavior clear. However, it does not explicitly distinguish this from the sibling `onenote_list_pages` tool, so it falls short of full sibling differentiation.

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

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

The description gives clear usage context: use this when searching by title, and it explicitly excludes body searches. It does not name an alternative tool for listing all pages or for full-text search, so it stops short of the top score.

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. It usefully discloses that the item is persisted on the task details object and that an unconfirmed-participant scenario triggers a confirmation gate – context an agent would not otherwise know. It omits what happens with duplicate item names, required permissions/scopes, and whether the task details object is overwritten.

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

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

Two short sentences, front-loaded with the action and its storage target. The second sentence is slightly ambiguous but not wasteful.

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?

A mutation tool with no annotations, no output schema, and 0% schema coverage needs more: expected return value, permission requirements, and idempotency/duplicate behavior are all missing. The storage-location and confirmation notes help, but the picture is still partial for a write operation.

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

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

Schema description coverage is 0%, so the description must compensate. It ties confirm_code to a confirmation flow, which adds meaning beyond the bare string type, but explains neither where that code comes from nor why a checklist item would involve other people – the linkage is confusing. title and task_id remain undocumented but are largely self-evident.

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+resource ('Add a checklist item to a Planner task') and notes where the data lives ('stored on task details'), which distinguishes it from the todo_add_checklist_item sibling by platform. It does not explicitly name the alternative, but the Planner-vs-To Do boundary is evident from the resource name.

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

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

Provides one real usage condition: involving people who haven't signed up requires user confirmation via confirm_code. It never states when to prefer this over todo_add_checklist_item or what prerequisites (task must exist, plan membership) apply.

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

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

With no annotations, the description carries the full burden: it usefully discloses the additive semantics and the confirmation requirement for unregistered assignees. However, it leaves out permission requirements, what happens on invalid AAD ids or duplicate assignees, and whether the call fails atomically — significant gaps for a mutation tool.

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

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

Two short sentences, front-loaded with the action and scope, with the confirmation caveat following. Dense and largely waste-free, though the parenthetical '(see confirm_code)' is cryptic enough to border on underspecification.

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 3-parameter mutation with no annotations and no output schema, the description covers the core action and the confirmation caveat but omits the return value (e.g., updated assignee list), failure modes, and the mechanics of the confirmation round-trip.

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 0%, so the description must compensate. It does add real meaning for assignee_ids (AAD user ids) and hints that confirm_code is the confirmation token, but task_id is never explained and the confirm_code workflow (how/when the code is obtained) remains opaque.

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

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

States a specific verb and resource (assign a task to users) and adds the crucial qualifier that this is additive to existing assignees, which implicitly distinguishes it from planner_unassign_task. It stops short of naming the sibling it contrasts with, so an agent must infer the comparison.

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

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

Gives one conditional rule (involving unregistered people needs user confirmation), which is useful routing guidance, but never states when to pick this over planner_update_task or planner_unassign_task, nor any prerequisite such as needing an existing task id from planner_get_task.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses the exact state change (percentComplete=100) and a confirmation requirement for certain external-people scenarios, but it does not clarify permissions, idempotency, behavior on already-completed tasks, or error conditions.

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

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

The description is two sentences, front-loads the core action, and has no wasted text. The secondary confirmation note follows the primary purpose efficiently.

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

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

For a simple two-parameter mutation tool, the core action and one conditional requirement are covered. However, with no annotations, no output schema, and 0% schema description coverage, the definition leaves important details about task_id and confirm_code usage under-specified.

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

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

Schema description coverage is 0%, so the description must explain both parameters. It references confirm_code and provides a condition for needing it, but does not explain how to obtain or format the confirmation code, and it gives no explicit description of task_id beyond the obvious parameter name.

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

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

The description states a specific verb and resource ('Mark a Planner task complete') and specifies the resulting state ('percentComplete=100'). This clearly distinguishes it from sibling mutation tools such as planner_update_task or planner_delete_task.

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

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

It gives clear context for the core action and adds a conditional rule for confirm_code when people who haven't signed up are involved. It does not explicitly compare against planner_update_task with percentComplete=100, but the intended use is still clear.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation but says nothing about required permissions, whether the bucket is returned, or what happens on failure — a significant gap for a write tool with zero annotation coverage.

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

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

A single short sentence with no filler, but it is terse to the point of under-specification rather than efficient. Nothing is front-loaded beyond the bare purpose.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter coverage, the description should explain prerequisites and return behavior. As written, an agent knows only the name of the action.

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

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

Schema description coverage is 0% for two required parameters. "in a plan" loosely hints that plan_id identifies the parent plan, but neither plan_id's format nor name's constraints (uniqueness, length, ordering) are explained anywhere.

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

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

States a specific verb and resource ("Create a bucket") plus scope ("in a plan"), which distinguishes it from planner_list_buckets and planner_create_task. It lacks any explicit sibling differentiation, but the verb+resource pairing 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 on when to create a bucket versus using planner_list_buckets first, no prerequisites (e.g. must the caller be a plan member?), and no mention of duplicates or naming constraints. The agent must infer all usage context.

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

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

No annotations exist, so the description bears the full burden. It does disclose a genuinely non-obvious behavioral trait — that assigning users who haven't signed up requires confirmation via confirm_code — which is valuable. But it omits permissions/scopes required, error behavior for invalid plan_id or bucket_id, and whether task creation is idempotent.

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

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

Three short lines, front-loaded with the core action, then a compact parameter glossary. No filler sentences and nothing repeated from the schema titles.

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 an 8-parameter mutation tool with no annotations and no output schema, the description covers the tricky inputs but not the surrounding contract: what a successful call returns (task id?), what happens if plan_id or bucket_id is invalid, or how confirm_code is obtained. Adequate to attempt a call, but 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?

Schema coverage is 0%, so the description must compensate, and it does for the non-obvious parameters: date format for due_date/start_date, AAD user ids for assignee_ids, and the 0-10 priority scale with named anchors. It leaves bucket_id and plan_id unexplained, but those are largely self-describing names.

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 opening sentence gives a specific verb and resource ("Create a Planner task") that clearly separates it from planner_update_task, planner_delete_task, or the todo_* family. It does not, however, explicitly contrast itself with planner_assign_task or todo_create_task, which an agent might reasonably confuse it with.

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

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

Usage context is only implied: the note about unregistered assignees requiring confirmation gives a conditional workflow hint, but there is no statement of prerequisites (does plan_id need to exist? must a bucket exist before bucket_id?), nor any guidance on when to use this versus planner_assign_task or planner_update_task.

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 full behavioral burden. It does add a genuinely useful disclosure – a required confirmation flow (confirm_code) when the task involves unregistered people – but omits whether deletion is permanent, what happens to checklist items/assignments, and what permissions are needed.

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

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

Two short sentences with the destructive action front-loaded and the exception condition second. The phrase 'see confirm_code' is slightly circular, but nothing is padded or wasted.

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 an irreversible mutation with zero annotation coverage and two undocumented parameters. The output schema covers return values, but the description still leaves out permanence, permission requirements, and the mechanics of confirm_code – significant gaps for a delete operation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It references confirm_code but only by name ('see confirm_code'), without explaining where the code comes from, its format, or what happens if it is omitted; task_id is not addressed at all.

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

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

States a specific verb and resource ('Delete a Planner task'), which is unambiguous on its own. It does not distinguish itself from nearby siblings such as todo_delete_task or planner_complete_task, so an agent must infer the Planner-vs-To Do distinction from the name alone.

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

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

There is no statement of when to choose this over siblings like planner_complete_task or todo_delete_task. The only procedural guidance is the conditional note that tasks involving people who haven't signed up require the user's confirmation via confirm_code, which is a precondition rather than tool-selection 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 behavioral burden. 'Find' implies a read-only lookup and the parenthetical explains the return purpose, but it omits permissions, matching rules/case sensitivity, result limits, and an explicit no-side-effects statement.

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 leads with the action, then supplies the search method and return purpose.

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

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

An output schema exists, so return-value details need not be repeated. For a simple two-parameter lookup, the description covers purpose, query semantics, and assignment context, though explicit plan_id explanation and alternative-tool routing are missing.

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

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

Schema description coverage is 0%, so the description must compensate. It meaningfully defines the query parameter as a name or email substring; plan_id is only implied by 'plan members' but is reasonably clear from context for a two-parameter lookup.

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 gives a specific verb and resource ('Find plan members'), the search mechanism ('by name or email substring'), and the return purpose ('returns user ids for assignment'). This clearly distinguishes it from the sibling list-all operation planner_list_plan_members.

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

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

The phrase 'for assignment' implies a use context, but the description does not explicitly say when to use this instead of planner_list_plan_members or planner_assign_task. Guidance is present but implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but the description does not state permission requirements, what happens if the plan is missing, or what 'metadata' includes.

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. However, its brevity contributes to under-specification rather than purely earning conciseness.

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

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

For a simple one-parameter read tool with no annotations and no output schema, the description is still too thin. It does not clarify return contents, error behavior, or any usage constraints an agent would need to invoke it confidently.

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

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

Schema description coverage is 0%, and the description does not explain the plan_id parameter beyond the phrase 'a plan's.' The parameter name is self-descriptive, but the description adds essentially no semantic detail to compensate for the missing schema 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 states a specific verb and resource: 'Get a plan's metadata.' This clearly identifies the operation, but it does not distinguish it from sibling tools such as planner_list_plans or planner_get_task beyond the resource noun. The word 'metadata' is also somewhat generic about what is returned.

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 like planner_list_plans or planner_get_task. Retrieval usage is implied by 'Get,' but no exclusions, prerequisites, or selection criteria 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?

No annotations exist, so the description carries the full behavioral burden. The word 'Get' and the enumeration of returned sub-objects signal a read operation with detail expansion, but it says nothing about required permissions, behavior when the task id is invalid or the task is deleted, or pagination/size limits.

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

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

One short sentence, front-loaded with the verb and resource, followed by the detail-expansion note. Nothing is wasted.

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

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

For a one-parameter read tool with no output schema, the description usefully tells the agent what comes back (checklist, description, references). The remaining gap is failure behavior for a missing task id.

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

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

The single parameter task_id has 0% schema description coverage and the description does not mention it at all — no format, source, or validity constraints. The description adds no meaning beyond the bare property name.

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

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

States a specific verb and resource ('Get a Planner task') and goes further by naming the expanded parts included (checklist, description, references). It is clearly distinct from planner_list_tasks, though it never names the sibling explicitly.

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

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

Use is implied: retrieve one task by id rather than enumerating. There is no explicit statement of when to prefer this over planner_list_tasks or planner_get_plan, and no prerequisites or exclusions 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 behavioral burden; the word 'List' at least signals a read-only, non-destructive operation. However, it discloses nothing about permissions, ordering, pagination, or behavior for an invalid plan_id, which is a real gap for an unannotated tool.

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

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

One short sentence with no filler and the resource front-loaded after the verb. It is efficient, though the brevity borders on under-specification rather than tight writing.

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

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

The tool is simple (one required param) and an output schema exists, so return values need not be explained. Still, the description omits where plan_id comes from and offers no differentiation from the many sibling planner/todo list tools, leaving a small but real 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 0% and the single required parameter plan_id is not mentioned at all. The phrase 'of a plan' only loosely implies that plan_id identifies the target plan, adding almost no syntax or format detail beyond the bare 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?

States a specific verb ('List') and resource ('buckets (columns) of a plan'), and the parenthetical clarifies the Planner-specific term 'bucket' for agents unfamiliar with it. It does not distinguish itself from siblings like planner_list_plans or planner_list_tasks, 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 explicit when-to-use or when-not-to-use guidance, and no named alternative. Usage is only inferable from the verb-plus-resource phrasing, and nothing tells the agent to call planner_list_plans first to obtain a plan_id.

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, and it does disclose the key behavioral fact that membership is resolved through the owning M365 group. It says nothing about whether the call requires group read permissions, whether results are paginated, or what happens when the group has no members — gaps that matter for an unannotated tool.

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

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

A single tight sentence with the scope stated first and the intended use in a compact parenthetical. No filler and nothing redundant.

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

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

An output schema exists, so return values need no explanation, and the tool is a simple single-parameter read. The remaining shortfall is the missing link to planner_assign_task and planner_find_member, which would complete the workflow picture.

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 0%, so the description must compensate for the single undocumented parameter, and it does not — plan_id's expected format or where to obtain it is never mentioned. The parameter is largely self-explanatory by name, so this is a moderate rather than severe 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 states a specific verb and resource ('List the members of a plan's owning M365 group') and clarifies a non-obvious scoping fact: the members come from the group that owns the plan, not the plan itself. It does not explicitly distinguish itself from the sibling planner_find_member, which could appear to do something similar.

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 parenthetical '(to get user ids for assignment)' implies the workflow — call this before assigning tasks — which is genuinely useful context. However, it never names the follow-up tool (planner_assign_task) or the alternative (planner_find_member), so the agent must infer which one to use.

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

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

No annotations are provided, so the description carries more burden. It usefully discloses the scope of results (shared plans plus M365 group plans), which is behavioral context beyond the schema. But it does not mention pagination, permission requirements, or that the operation is read-only beyond the implied 'List' verb.

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 states the resource and scope immediately.

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

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

Given zero parameters and an output schema, the description is nearly complete for a simple list tool. It defines what is listed and the visibility boundary, though it could optionally clarify that results are read-only and may be paginated.

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

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

There are zero parameters, so the baseline is 4. The description correctly implies a no-argument listing operation, and there is no parameter semantics to explain.

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 ('Planner plans') and defines the visibility scope as plans shared with the user plus plans in their M365 groups. It is clear what the tool returns, though it does not explicitly differentiate itself from siblings such as planner_get_plan or planner_list_tasks.

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

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

Usage is implied: an agent can infer this is the discovery tool for plans the user can access. However, there is no explicit guidance on when to use this versus alternatives like planner_get_plan or planner_my_tasks, nor any stated exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only listing but does not disclose pagination, whether completed tasks are included, permissions, or whether results span all buckets.

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 is front-loaded and easy to parse, though its brevity contributes to gaps elsewhere.

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

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

An output schema exists, so return values do not need explanation. However, with no annotations and no parameter documentation, the description is only minimally adequate for an agent to understand the tool's behavior and limits.

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

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

The single parameter plan_id has 0% schema description coverage, and the description only repeats that the operation is scoped to a plan. It adds no format, source, or expected-value guidance for plan_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 clear verb ('List') and resource ('tasks') and scopes it to a plan. This distinguishes it from planner_my_tasks, but 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?

There is no guidance on when to use this tool versus alternatives such as planner_my_tasks or planner_list_buckets. Usage is only implied by the phrase 'in a plan'.

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 load: 'List' implies a read-only, non-destructive operation and the scope is clarified as the cross-plan 'Assigned to me' view. It says nothing about pagination, ordering, or whether completed tasks are included, which matters for a cross-plan aggregation tool.

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

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

A single sentence with the scope constraint front-loaded and no filler. Every clause 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?

An output schema exists, so return values need not be explained, and a zero-param read tool needs little more than scope. The only real gap is whether the result set is filtered by status or paginated across many plans.

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?

Zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly reflects that the tool takes no arguments.

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

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

States a specific verb and resource ('List Planner tasks') plus the scope ('assigned to me across all plans'), which implicitly separates it from planner_list_tasks. It stops short of naming that sibling explicitly, so differentiation relies on the agent inferring it from 'across all plans.'

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 parenthetical 'the Assigned to me view' implies the use case (my tasks, not a plan's tasks), but there is no explicit when-to-use or when-to-prefer-a-sibling statement. With planner_list_tasks in the sibling set, an explicit routing sentence would have earned a higher score.

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 behavioral disclosure. It usefully reveals a confirmation flow for involving non-signed-up people via confirm_code, but does not say whether it overwrites or appends, required permissions, or what happens to existing content.

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

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

The description is two short sentences, front-loading the core action and then adding a caveat. It is efficient, though the parenthetical reference to confirm_code is slightly 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?

For a mutation tool with no annotations, no output schema, and 0% schema description coverage across three parameters, the description is too thin. It omits overwrite behavior, permissions, and return semantics needed for confident invocation.

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

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

Schema description coverage is 0%, so the description should compensate. It explains that confirm_code relates to confirmation for involving people, but leaves task_id completely undocumented and does not explain the format or how confirm_code is obtained.

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: setting the task's description on plannerTaskDetails. It is distinguishable from planner_update_task in that it targets only the description field, though it does not explicitly acknowledge that sibling.

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

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

Usage is implied by the narrow purpose, and the description hints that confirm_code is needed when involving unsigned-up people. However, it gives no explicit guidance on when to use this versus planner_update_task or how to obtain the confirmation.

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 present, the description must carry the full behavioral burden. It usefully discloses that some unassignments require end-user confirmation via confirm_code, which is real behavioral context beyond the schema. However, it omits permissions required, what happens when a listed assignee is not currently assigned, whether the operation is reversible, and how errors are surfaced.

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

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

Two sentences with no filler, and the core purpose is front-loaded ahead of the conditional confirmation note. Slightly terse given the parameter ambiguity, but structurally sound.

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 three-parameter mutation tool with no annotations and no output schema, the description covers the operation's intent and one important edge-case workflow. It remains incomplete on required permissions, partial-failure behavior, and return information, which an agent needs for reliable invocation.

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

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

Schema description coverage is 0% across all three parameters. The description only hints at confirm_code by name ('see confirm_code'), without explaining its format, how it is obtained, or when it is supplied. It says nothing about task_id or the semantics of multiple assignee_ids.

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

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

The description opens with a specific verb and resource: 'Remove one or more users from a task's assignees.' This clearly distinguishes it from the sibling planner_assign_task, which does the inverse operation.

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

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

It provides a concrete conditional workflow rule: involving unregistered people requires the user's confirmation and therefore the confirm_code path. It does not explicitly name planner_assign_task as the alternative for the opposite operation, but the scope of use is clear from the stated purpose.

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

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

With no annotations, the description usefully discloses that ETag is handled automatically, gives percent_complete values, and warns about confirmation for unsigned-up people. It still omits broader mutation behavior such as partial-update semantics, permissions, error cases, and what confirm_code is for.

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

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

The description is short and front-loaded, with no wasted preamble. The fragment-style percent_complete notation is efficient but slightly 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?

For an 8-parameter mutation tool with no annotations and no output schema, the description is incomplete. It should cover more parameter meanings, update behavior, confirmation/confirm_code flow, and distinctions from specialized planner siblings.

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

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

Schema description coverage is 0% across 8 parameters, and the description explains only percent_complete. It leaves title, due_date, priority, bucket_id, start_date, and confirm_code without semantic guidance beyond their names.

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+resource: "Update task fields." It is clear what the tool does, but it does not distinguish itself from siblings such as planner_complete_task, planner_assign_task, or planner_set_description.

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

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

Provides one concrete usage condition: tasks involving people who have not signed up require user confirmation. However, it gives no explicit routing versus related siblings like planner_complete_task, planner_assign_task, or planner_unassign_task.

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 says nothing about whether duplicate item names are allowed, what the response contains, whether the item appears immediately, or what permissions/scope the list_id requires.

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 compact sentence with the core action front-loaded and no filler. It is efficient, though borderline under-specified rather than tight.

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 zero schema description coverage, this description leaves too much open: no return value, no validation rules, no parent-object existence 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?

Schema description coverage is 0% and the description names none of the three parameters. The agent must infer that list_id is the containing list, task_id the parent task, and display_name the item's text; nothing is said about ID formats or length limits.

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 ('Add') and resource ('checklist item (subtask)') with the parent task as the target, which is unambiguous. It implicitly distinguishes from todo_check_checklist_item and todo_delete_checklist_item by naming the creation action, though it never explicitly contrasts with 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?

No guidance on when to use this versus todo_list_checklist_items or todo_check_checklist_item, and no prerequisites such as the task/list needing to exist or whether the item must be created before it can be checked.

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 and largely drops it. 'Mark' implies a mutation on an existing item, but nothing is said about whether the call is idempotent, whether it requires write permission on the list, or what happens when checked is omitted (the schema defaults it to true, which silently forces a check).

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 padding, but its brevity is driven by under-specification rather than efficiency. The checked/unchecked framing does at least lead with the state transition.

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 four-parameter mutation with no annotations, no output schema, and no parameter documentation, this description leaves the agent without the information it needs. It does not identify what a checklist item is nested under or what the call returns.

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

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

Schema description coverage is 0%, so the four parameters are documented only by their bare titles (list_id, task_id, item_id, checked). The description clarifies only the semantics of 'checked' in the loosest way and adds nothing about the three ID parameters or their relationship (a checklist item lives under a task inside a list).

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 ('Mark') and resource ('checklist item') plus the state transition being applied (checked/unchecked), which is enough to distinguish it from todo_add_checklist_item and todo_delete_checklist_item. It does not explicitly name siblings, but the resource-level specificity carries it.

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

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

No guidance on when to use this versus todo_add_checklist_item, todo_delete_checklist_item, or todo_list_checklist_items. There is also no statement of prerequisites, such as the item having to already exist on the task.

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

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

With no annotations, the description carries the full burden: it does not say whether the call is idempotent on an already-completed task, whether it requires write permissions, whether it mutates only the status or also timestamps, or what is returned. 'Mark completed' implies mutation but discloses no behavioral traits 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?

Four words with zero waste and the verb front-loaded, but the brevity is under-specification rather than efficiency given two undocumented required params and no annotations.

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?

A mutation tool with no annotations, no output schema, and no parameter documentation. An agent could call it, but has no information on permissions, idempotency, failure modes, or 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?

Schema description coverage is 0% for two required parameters. The description says nothing about list_id or task_id — not whether list_id must be the owning list of the task, nor the identifier format — leaving both params documented only by their bare titles.

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 (mark completed) and resource (task), so the operation itself is unambiguous. It does not differentiate from siblings such as todo_update_task or planner_complete_task, which could plausibly also flip completion state.

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 indication of when to use this versus todo_update_task or the planner equivalents. The agent must infer that this is the dedicated completion path rather than a generic status update.

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 disclosure burden, yet it says nothing about required permissions, whether display names must be unique, what happens on duplicate names, or whether the operation is reversible. For a mutation tool with zero annotation coverage 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?

One short, front-loaded sentence with no wasted words. It is efficient, though its brevity is partly under-specification rather than deliberate economy.

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

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

The tool is simple (one required string, no nesting, no output schema), so the description is minimally sufficient to invoke it. However, it omits what the call returns (e.g., a list ID that todo_create_task would need), which matters for chaining calls.

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

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

The single parameter display_name has 0% schema description coverage, and the description adds no meaning such as format, length limits, uniqueness constraints, or how it differs from any internal list name. The only parameter is effectively undocumented in both places.

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?

Clear specific verb ('Create') plus resource ('To Do list'), which is unambiguous against siblings like todo_update_list and todo_delete_list whose names carry the contrasting operation. It does not explicitly name an alternative, but the CRUD naming convention makes the distinction obvious.

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 statement of when to use this versus todo_create_task or the planner equivalents, and no prerequisites such as whether the caller needs an existing list or account context. 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?

No annotations are provided, so the description carries the full burden. It discloses input formats for dates and importance values but says nothing about mutations being permanent, permission requirements, how time_zone interacts with due_date, or what the call returns — significant gaps for a write operation with zero annotation coverage.

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

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

Three short sentences, front-loaded with the action and then the format constraints; nothing is padded. The fragmentary 'importance: low|normal|high' style is terse but readable, so it loses a point only for telegraphic phrasing rather than waste.

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 7-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description should explain list_id sourcing, time_zone semantics, and the effect of the call. It covers only the value formats, leaving the agent to guess at the most consequential inputs.

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 0%, but the description compensates for the non-obvious parameters: date formats for due_date/reminder_date, allowed values for importance, and the meaning of body. It leaves time_zone (which defaults to UTC and likely governs how date strings are interpreted), list_id, and title entirely unexplained, so coverage is only partial.

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?

Specific verb+resource: 'Create a To Do task' clearly distinguishes creating a task from creating a list. However, with a sibling planner_create_task in the tool set, the description never explains the To Do vs Planner distinction, so an agent must infer the boundary from the name prefix alone.

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 versus todo_update_task (for adding to existing tasks) or planner_create_task (for Planner items). The prerequisites are unstated — nothing says list_id must reference an existing list obtainable from todo_list_lists or todo_find_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?

No annotations are provided, so the description carries the full behavioral burden for a destructive operation, yet it adds nothing beyond the verb: no mention of irreversibility, permission requirements, whether deletion is idempotent or errors on a missing item, or whether other checklist items are renumbered. 'Delete' is the only behavioral signal, and that is already in 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?

A single front-loaded sentence with zero filler, so nothing is wasted. Its brevity is appropriate in form, though the same brevity is what leaves the other dimensions under-specified.

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

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

For a destructive three-parameter tool with no annotations and no documented parameters, the definition should cover scope (does it delete one item or the whole checklist?), confirmation expectations, and failure modes. An output schema exists, so return values needn't be described, but everything else an agent needs to call this safely 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 0% across three required parameters, so the description needed to compensate and does not — it never explains the list_id → task_id → item_id nesting or the expected ID format. The parameter names are semi-self-describing, which is the only reason this is not a 1.

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 and resource ('Delete a checklist item'), which cleanly separates it from the delete-list and delete-task siblings in the namespace. It stops short of differentiating it from the adjacent todo_check_checklist_item / todo_add_checklist_item operations, but the resource 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 on when to use this versus todo_delete_task, todo_check_checklist_item, or todo_list_checklist_items, and no prerequisites are stated (e.g. that the item must currently exist under the given task). The agent must infer the workflow 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 provided, the description carries the full behavioral burden, yet it only says 'Delete'. It does not disclose whether deletion is permanent, whether contained tasks are also removed, what permissions are required, or whether the operation can be undone — critical details for a destructive operation.

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

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

A single short sentence with zero filler and the key verb front-loaded. Its brevity is not the problem; the missing information is captured in 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 destructive tool with no annotations and an undocumented parameter, the description is too thin. The presence of an output schema reduces the need to explain return values, but the description still fails to cover permissions, cascading effects, and parameter sourcing.

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

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

Schema description coverage is 0%, so the description carries full responsibility for explaining list_id, but it says nothing about it. An agent cannot tell whether list_id is a GUID, a display name, or how to obtain it (e.g., from todo_list_lists).

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

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

The description states a specific verb and resource ('Delete a To Do list'), which clearly distinguishes it from sibling tools like todo_delete_task and todo_delete_checklist_item. It stops short of naming those siblings, but the resource scope is unambiguous.

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

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

There is no guidance on when to use this versus todo_update_list, todo_delete_task, or other siblings, and no prerequisites or confirmation requirements are mentioned. The agent must infer usage entirely from the name and one-line 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 disclosure burden, yet it says nothing about irreversibility, whether checklist items/subtasks cascade-delete, or required permissions. The only signal is the implicit destructiveness of the word "delete".

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?

At four words there is no waste, but this is under-specification rather than conciseness. Nothing is front-loaded because there is nothing to front-load.

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

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

An output schema exists, so return values need no explanation, but for a destructive two-parameter mutation with no annotations this description omits the essentials: what gets destroyed, cascade behavior, and parameter meaning. It is not complete enough to call safely.

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

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

Schema description coverage is 0% for both required parameters (list_id, task_id), and the description does not mention either one. There is nothing explaining that a task must be identified jointly by its list and its id, which is the key invocation detail.

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?

"Delete a task" gives a clear verb and resource, but it is almost a verbatim restatement of the tool name todo_delete_task and draws no distinction from siblings like todo_delete_list or todo_delete_checklist_item. An agent knows the general operation but nothing about its scope or effect.

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

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

No guidance on when to use this versus deleting a whole list, completing a task, or removing a checklist item. There are no preconditions, no mention of whether the task must exist, and no exclusions.

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

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

Without annotations, the description carries the burden and does real work: it discloses case-insensitive matching, that only the FIRST match is returned (a significant truncation behavior for duplicate names), and that a miss returns {}. It omits any explicit read-only/no-side-effects statement, but that is strongly implied by "Find ... Returns".

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

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

Two short sentences, front-loaded with the action and key, followed by return behavior. Nothing is wasted or redundant.

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

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

For a one-parameter read tool with no output schema, the description covers the essential call-time behavior (name matching, first-match return, empty-object miss). Only the exact-vs-partial match question and duplicate-name ordering remain unspecified.

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 0%, so the description must compensate, and it partially does by clarifying the single parameter is a case-insensitive display name. It leaves a key ambiguity unresolved: whether matching is exact or substring/prefix, which directly affects how callers must supply the name.

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

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

States a specific verb ("Find") and resource ("To Do list") plus the lookup key (display name), which is meaningful against siblings like todo_create_list or todo_delete_list. It does not explicitly contrast with todo_list_lists, leaving the by-name vs. enumerate distinction to inference.

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

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

Usage is only implied: an agent can infer this is the tool for when a list name is already known, but the description never states when to prefer it over todo_list_lists or how to recover from an empty result (fall back to listing?). No exclusions or alternatives are named.

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 disclosure burden. "Get" strongly implies a read-only operation, but the description does not state permissions, error behavior, or what "full detail" actually returns, leaving meaningful behavioral gaps.

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 efficient, though its brevity contributes to the missing usage and parameter detail rather than being a structural flaw.

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 retrieval tool with no annotations and no output schema, the description is under-specified. It does not explain the required identifiers, what "full detail" includes, or what the caller should expect to receive.

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

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

Schema description coverage is 0%, and the description does not mention either required parameter, list_id or task_id. There is only a weak implication that a single task is identified, but no real guidance on the two identifiers the agent must supply.

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

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

The description uses a clear verb-and-resource pair, "Get" and "a single To Do task," and specifies scope with "single" and "full detail." It distinguishes the tool from list-style siblings like todo_list_tasks, though it does not explicitly name alternatives.

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

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

The description gives no explicit guidance on when to use this tool instead of todo_list_tasks, todo_update_task, or planner_get_task. The only implied usage is that this retrieves one task rather than a list, which the agent must infer.

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, yet it says nothing about permissions, pagination, ordering, or empty-result behavior. Beyond implying a read operation, it adds no behavioral context.

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

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

A single well-formed, front-loaded sentence with no filler. It is terse rather than bloated; the brevity is a concreteness problem better captured elsewhere.

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

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

For a tool with two undocumented required parameters and no annotations, the description should explain list_id vs task_id and any scoping rules. An output schema exists so return shape need not be covered, but the input side is left almost entirely unexplained.

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

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

Schema description coverage is 0% for both required parameters. The description hints that task_id identifies 'a task' but never explains list_id (the parent list) or the relationship between the two identifiers, leaving an important 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?

States a specific verb ('List') and resource ('checklist items (subtasks) of a task'), and the parenthetical '(subtasks)' makes the resource unambiguous. It distinguishes itself from the sibling mutation tools (todo_add_checklist_item, todo_check_checklist_item) by being the read/list variant, though it doesn't name an 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?

The description gives no guidance on when to use this versus todo_get_task or todo_list_tasks, nor any prerequisites. Usage is only implied by '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?

No annotations are provided, so the description carries the burden; 'List all' weakly signals a read-only, non-mutating operation. It says nothing about pagination, result limits, ordering, or permissions, though the low risk of a zero-parameter read tool limits the cost of those omissions.

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 the verb and scope first and the return shape appended. No filler and nothing an agent must read past to act.

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

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

With an output schema covering the return shape and no parameters to explain, the description is nearly sufficient. The only real gap is the absence of any routing hint toward todo_find_list, which matters given how many list-related siblings exist.

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 takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the parenthetical naming the returned fields adds a small amount of useful 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?

States a specific verb and resource (list Microsoft To Do task lists) and names the fields returned. It does not explicitly differentiate itself from the sibling todo_find_list, leaving the agent to infer the distinction between enumerating all lists and finding a specific one.

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

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

The word 'all' implies this is the enumeration path, but there is no explicit when-to-use statement and no mention of todo_find_list as the alternative when the agent already knows the list name or id. Usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It tells the agent this is a read operation and that filtering is optional, but it does not disclose pagination behavior despite a 'top' parameter defaulting to 100, nor result ordering, empty-list handling, or permission requirements.

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

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

Two sentences, front-loaded with the core action, and every clause carries information. It is slightly compressed — the enum list is appended without explanation of default/null behavior — but there is no filler.

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

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

An output schema exists, so return values needn't be explained, and the status enum is a useful addition. Still, for a 3-parameter list tool with zero annotation coverage, the missing discussion of pagination ('top' default 100) and list_id semantics leaves the definition only minimally 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 0%, so the description must compensate, yet it only documents the status parameter's allowed values (which the schema itself does not enum-constrain). The required list_id and the 'top' parameter are left unexplained, including whether 'top' caps page size or how it interacts with pagination.

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

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

States a specific verb and resource ('List tasks') plus its scope ('in a list'), which clearly separates it from siblings like todo_get_task or todo_list_lists. It stops short of naming an alternative or clarifying contrast with planner_list_tasks, so it is clear but not fully sibling-differentiated.

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

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

Usage is implied by 'in a list' and the optional status filter, so an agent can infer when it applies. However, there is no explicit when-to-use guidance, no mention of prerequisites (e.g. needing a valid list_id), and no pointer to alternatives such as todo_find_list for locating a list first.

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. It implies a mutation but says nothing about permissions, whether the rename is reversible, what happens to existing tasks, or what error occurs for an invalid list_id.

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 short sentence with no filler, so it is concise, but the brevity reflects under-specification rather than economical phrasing of useful content.

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

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

For a two-required-parameter mutation tool with no annotations, no output schema, and zero schema descriptions, the description leaves too much unspecified: target identification, new-value semantics, and failure modes are all absent.

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

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

Schema coverage is 0%, so the description must compensate and does not. 'Rename' weakly implies display_name is the new name, but list_id is never explained (e.g., that it identifies the target list) and no format or constraints are given for either parameter.

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

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

States a specific verb (Rename) and resource (To Do list), which clearly separates it from todo_create_list, todo_delete_list, and the task-level siblings. It does not explicitly say it is the only list-mutation-other-than-delete tool, but the verb+resource 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 on when to use this versus todo_create_list or todo_delete_list, and no prerequisites such as needing an existing list_id. The agent must infer everything from the name 'update'.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It usefully indicates partial updates and enumerates status values, but it omits permissions, side effects, whether omitted fields remain unchanged, error behavior, and return characteristics.

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 front-loaded and has no wasted wording. However, for a nine-parameter mutation tool with zero schema description coverage, it is arguably too terse to be fully appropriately sized.

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 incomplete for a complex mutation tool with no annotations, no output schema, and 0% schema description coverage. It covers partial updating and status values, but leaves most parameter semantics and key behavioral details unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate for nine undocumented parameters. It only adds meaning for the status parameter by listing allowed values; list_id, task_id, body, title, due_date, time_zone, importance, and reminder_date remain unexplained by both schema and description.

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 and resource: updating a task's fields. It also clarifies that the tool supports partial updates via 'any subset of a task's fields' and lists valid status values. It does not explicitly distinguish itself from sibling tools like todo_complete_task, which is why it falls short of a 5.

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

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

The description gives no guidance on when to choose this tool over alternatives such as todo_complete_task or planner_update_task. It implies partial updates and status changes but provides no exclusions, prerequisites, or contextual conditions for use.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the call doubles as an auth check, which is genuinely useful behavioral context, but says nothing about the return shape, error behavior on expired tokens, or latency/resilience.

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 the resource first and the secondary purpose in parentheses. No filler.

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

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

For a trivial zero-param identity call with no output schema, the description covers what an agent needs to decide to call it. Naming the returned fields (displayName, mail, id) would close the last 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 tool takes zero parameters, so there is nothing for the description to explain. Baseline 4 applies for a no-arg 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?

States a specific verb (return) and resource (the signed-in user), which is unambiguous and easily separated from the todo/planner/onenote siblings. It doesn't explicitly name siblings, but none are close enough to confuse it with.

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 parenthetical '(verifies Graph auth is working)' implies a diagnostic use case, which is helpful context. It doesn't state when not to use it or what to do if it fails, leaving the usage guidance implied rather than explicit.

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