reclaimai

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

The annotation destructiveHint=true already indicates a mutation. The description adds no further behavioral details beyond the REST method (POST), which reinforces mutation but does not explain side effects, requirements, or what exactly changes. It neither contradicts annotations nor enriches them significantly.

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

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

The description is only two sentences, with the purpose front-loaded in the first sentence and the REST endpoint in the second. Every sentence serves a purpose, and there is no redundant or filler content.

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

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

For a simple two-parameter tool with no output schema, the description is sufficient. It states the action and provides the endpoint. It does not cover potential errors or prerequisites, but those are less critical given the tool's simplicity and the presence of schema descriptions.

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

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

The input schema provides 100% coverage of parameter descriptions ('id' as task id, 'minutes' as minutes to add). The description does not add additional semantic meaning beyond what the schema already states, so baseline 3 applies.

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

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

The description clearly states the action ('Add scheduled time to a task') with a specific verb and resource. It is distinct from siblings like log_work or update_task by focusing on adding scheduled time rather than logging or editing. The REST endpoint adds precision.

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 context of use is implied: you use this when you want to add scheduled time to a task. However, no explicit alternatives or exclusions are mentioned (e.g., when to use log_work instead). It provides clear context but no direct comparison or when-not-to-use guidance.

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

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

The description adds the important behavioral detail that Reclaim automatically schedules the task, which goes beyond the annotations. However, with destructiveHint=true present, it does not explain why creation is considered destructive, what side effects may occur to existing calendar events, or what happens after creation. It adds some value but leaves significant 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 two short sentences, front-loaded with the core purpose. The inclusion of the REST endpoint is slightly extra but not harmful. Overall, it is concise and well-structured, though the endpoint reference is not essential for an AI agent's invocation.

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?

Despite rich schema coverage, this is a complex creation tool with 9 parameters, no output schema, and a destructiveHint that is not explained. The description omits return value details, prerequisites, and side effects on the calendar. It is not complete enough for an agent to understand the full impact of calling this tool.

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

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

The input schema provides 100% description coverage for all 9 parameters, including enumerations and detailed comments. The description itself does not add parameter-specific semantics beyond the auto-scheduling behavior, which touches on time-related fields. The high schema coverage means the baseline of 3 is appropriate.

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

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

The description begins with 'Create a new task,' a specific verb and resource that clearly states the tool's purpose. It also distinguishes itself from sibling tools like reclaim_delete_task and reclaim_update_task by adding auto-scheduling behavior and the REST endpoint.

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

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

'Reclaim schedules it into your calendar automatically' implies when this tool is appropriate, but it does not explicitly mention alternatives or when not to use it, such as when using reclaim_add_time for manually adding calendar time. The guidance is useful but not fully explicit.

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

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

Annotations already indicate destructiveHint=true, and the description adds 'permanently' to signal irreversibility, which is meaningful additional context. Mentioning the REST DELETE endpoint also informs the agent of the underlying operation, though it does not describe any side effects or auth requirements.

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

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

The description is two short sentences, front-loaded with the primary action, and the REST endpoint is a useful supplementary detail. No redundant fluff.

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

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

For a single-parameter delete tool with annotations and no output schema, the description covers the core action, permanence, and endpoint. It could include more about response behavior, but it's adequate for the tool's simplicity.

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

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

The input schema has 100% coverage with id described as 'The task id to delete.' The description adds no additional parameter meaning beyond the schema, so a baseline score is appropriate.

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

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

The description uses the specific verb 'delete' with the resource 'task,' clearly distinguishing this tool from siblings like reclaim_mark_task_complete or reclaim_update_task. The phrase 'permanently' adds specificity about the nature of the deletion.

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 states the tool's purpose but does not explicitly say when to use it versus alternatives like marking a task complete. The context of 'permanently delete' implies it should be used when a task must be removed entirely, but no explicit alternative guidance is provided.

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

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

Annotations provide readOnlyHint=true, and the description's 'Get' aligns with that. The description adds the REST endpoint (GET /api/users/me) as extra context, but does not disclose other behavioral details like authentication requirements or response format. Since annotations cover the safety profile, this is adequate but not rich.

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

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

The description is a single, concise sentence that fully captures the tool's purpose and includes the REST endpoint for reference. No unnecessary words.

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 zero-parameter read-only tool with no output schema, the description is complete. It states what it returns (profile) and the endpoint, covering all necessary context.

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

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

The tool has zero parameters, so there is nothing to explain. A baseline of 4 is appropriate as the description needs no parameter compensation.

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 'Get the authenticated Reclaim user's profile' with a specific verb and resource. It is distinct from sibling tools that focus on tasks, habits, events, and time management, and it explicitly identifies the target resource.

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

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

The description implies usage for retrieving the current user's profile and is unambiguous in its purpose. It does not explicitly mention alternatives, but the sibling tools are all distinct resources, making when-to-use clear from context alone.

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

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

The readOnlyHint=true annotation already discloses the safety profile. The description adds the 'daily' qualifier and the REST endpoint, which provides some context beyond the annotation. However, it doesn't describe return format, error behavior, or response time, which are not critical for a simple read but would add completeness. Since annotations cover the safety aspect, this is adequate but not rich.

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

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

The description is two sentences: the first states the purpose, the second gives the REST endpoint. It is front-loaded with the core action, contains zero fluff, and every word earns its place. Ideal conciseness for this tool.

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

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

For a single-id getter with one required parameter, no output schema, and readOnly annotation, the description is complete. It tells you what it does and the REST path. Given the simplicity, no additional context is needed. The sibling tools suggest this is part of a larger API, but the description fully covers the use case.

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

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

The input schema fully describes the only parameter 'id' with 'The habit id.' The description echoes 'by id' but adds no extra meaning beyond the schema. With 100% schema coverage, a baseline of 3 is appropriate—the schema does the heavy lifting, and the description doesn't compensate further.

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 exactly what the tool does: 'Get a single daily habit by id.' This clearly distinguishes it from sibling tools like reclaim_list_habits (list all habits) and reclaim_get_task (different resource). The REST endpoint further clarifies the action.

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

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

The description implies when to use it: you need a specific habit id. It doesn't explicitly mention alternatives or exclusion criteria, but the context is clear—this is for fetching one item by id, as opposed to listing all. A brief mention of when not to use it would make it a 5, but the current wording is sufficient for a simple getter.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Get' is consistent. The description adds the REST endpoint reference, which is a minor behavioral detail, but no error cases, authentication needs, or other context are provided. With annotations covering safety, a score of 3 is appropriate.

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

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

Two short sentences, front-loaded with the core purpose and immediately followed by the REST path. No unnecessary words or repetition.

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

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

For a simple single-task retrieval with one required parameter and no output schema, the description fully states what it does and the endpoint. No return value explanation needed since output schema is absent, and the tool is straightforward.

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

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

The schema has 100% coverage, describing the id parameter as 'The task id.' The description reinforces this by saying 'by id' but adds no new meaning beyond the schema. Baseline 3 is correct.

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 'Get a single task by id' with a specific verb and resource, and the REST endpoint further reinforces the exact operation. It distinguishes from sibling tools like list_tasks (plural) and update_task/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?

The description implies use when you need one task by its ID, but it does not explicitly state when to prefer this over list_tasks or mention any exclusions or alternatives. Context is implied but not directly 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?

The annotations already declare readOnlyHint=true, so the description doesn't need to restate this. It adds the REST endpoint and optional window filtering, which are useful behavioral details. However, it doesn't disclose pagination or response format, which are common for list operations.

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

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

The description is extremely concise, using just three short sentences to cover purpose, REST endpoint, and optional parameters. Every sentence earns its place with no redundancy or fluff.

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

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

For a simple read-only list tool with two optional parameters, the description covers the core operation. However, the lack of an output schema means the description could have mentioned return value or pagination behavior, which are not addressed. This leaves a minor but notable gap.

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

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

The input schema provides 100% coverage with descriptions for both parameters ('End of the calendar events window' and 'Start of the calendar events window'). The description adds minimal extra meaning beyond 'optional start/end window', so the baseline of 3 is appropriate.

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

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

The description clearly states 'List calendar events' with a specific verb and resource, and adds the REST endpoint for precision. It is unambiguous and distinguishes itself from sibling tools like reclaim_list_tasks, which focus on different entities.

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 indicates usage by stating its function as listing calendar events and notes the optional start/end window for filtering. There are no explicit exclusions or alternatives, but the context is clear enough given the sibling tool set.

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

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

The annotations declare readOnlyHint=true, and the description adds the specific GET endpoint and the scope ('authenticated user's daily habits'). It does not contradict the annotations and provides context beyond them, though it lacks details on response format or pagination.

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

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

The description is a single sentence plus a REST reference, with no wasted words. It is front-loaded with the action and resource.

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

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

For a simple, parameterless list tool with a read-only annotation, the description is sufficient: it states the action, scope, and exact REST endpoint. It does not explain the return format, but no output schema is provided, so this is a minor gap.

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

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

The tool has no parameters, so the schema fully covers them. The description adds no param-specific information, but none is needed; baseline 4 applies.

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

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

The description clearly states the tool lists the authenticated user's daily habits, using a specific verb ('List') and resource ('habits'), and includes the REST endpoint. This distinguishes it from sibling tools like list_events and 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?

The description provides no guidance on when to use this tool versus alternatives such as reclaim_get_habit for a single habit. There is no mention of use cases or exclusions.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds the scope 'authenticated user's tasks' and the REST path 'GET /api/tasks', which reinforces the read-only nature and adds endpoint context. However, it does not disclose pagination behavior, return format, or ordering, so it provides limited extra value beyond annotations.

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

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

The description is concise, consisting of one clear sentence plus a REST endpoint reference. Every word adds value, and the most critical information (list tasks) is front-loaded.

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

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

For a simple listing tool with no parameters, the description covers the essential scope (authenticated user) and the endpoint. Given the readOnly annotation and absence of an output schema, it is sufficiently complete, though it could optionally mention pagination or result summary, which is not necessary.

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

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

With zero parameters and 100% schema coverage, the baseline is 4. The description does not need to add parameter details, and any parameter-related info would be redundant since there are none.

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 explicitly states the verb 'List' and the resource 'tasks' with scope 'authenticated user's tasks', making it clear this is a list operation. The plural 'tasks' distinguishes it from reclaim_get_task (singular). The REST method GET further clarifies the action.

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

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

No guidance is given on when to use this tool versus alternatives like reclaim_get_task, reclaim_list_habits, or other task-related siblings. It does not mention any exclusions, prerequisites, or when not to use it, leaving the agent to infer 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?

The description only states the action and the REST endpoint. It adds no behavioral context beyond the destructiveHint annotation, such as what gets modified, whether logging is reversible, or if any permissions are required. The annotation covers the safety signal, but the description itself contributes little.

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

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

The description is a single sentence plus the REST endpoint, front-loaded with the primary action. Every word earns its place and there is no irrelevant information.

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

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

The tool is a simple mutation with all parameters documented in the schema and the destructiveHint annotation flagging side effects. However, there is no output schema and the description does not mention what the response looks like or what the side effects actually are, leaving the agent with incomplete information for a full understanding.

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 description does not mention parameters, but the input schema fully documents all three parameters (id, end, minutes) with descriptions. With 100% schema description coverage, the schema carries the semantic weight, so the baseline of 3 applies.

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

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

The description clearly states the action: 'Log completed work time against a task.' The verb 'log' and the resource 'task' are specific, and this distinguishes it from sibling tools like create_task, update_task, start_task, or stop_task, which perform different operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or alternatives such as reclaim_start_task or reclaim_stop_task, which might be related to tracking work time.

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

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

Annotations already indicate destructiveHint, and the description adds the REST method and path (POST /api/planner/done/task/{id}). It does not disclose side effects like whether the action is reversible or what happens if the task is already complete, but it doesn't contradict annotations.

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

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

Two concise sentences: one for the action and one for the REST endpoint. No filler or repetition of schema details.

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

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

For a simple tool with one parameter and no output schema, the description provides sufficient context: what the tool does and the underlying API call. The destructive annotation covers safety, making this complete.

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

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

Schema coverage is 100%, with the 'id' parameter described as 'The task id to mark complete.' The description adds the URL template, which implies id is a path parameter, but this is marginal beyond the schema.

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

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

The description clearly states the action ('Mark a task as done') and the resource ('in the planner'), which distinguishes it from sibling tools like reclaim_mark_task_incomplete. The REST endpoint provides additional specificity.

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

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

The description implies the proper use case: marking a task complete. It doesn't explicitly mention alternatives or exclusions (e.g., use reclaim_mark_task_incomplete to undo), but the context is clear enough for a simple tool.

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

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

The description adds behavioral context beyond the annotations: it clarifies that 'reopen' means 'unarchive' and provides the exact REST method and path. It does not elaborate on any destructive side effects, but the destructiveHint annotation already signals potential impact, so the description adds useful details without contradiction.

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

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

The description is a single, information-dense sentence followed by the REST endpoint. Every word earns its place, with no fluff or repetition of the title.

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 single-parameter mutation with no output schema, the description is complete: it explains the purpose, the scope ('in the planner'), and the API call. The agent has enough context to invoke the tool correctly.

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

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

The schema description covers the only parameter fully ('The task id to mark incomplete'). The description itself does not add extra meaning beyond the schema, but no additional explanation is necessary given the simple, well-documented parameter.

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

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

The description clearly states the specific action: 'Reopen a completed task (unarchive)'. It names the resource ('task'), the context ('in the planner'), and provides the REST endpoint. This fully distinguishes it from siblings like reclaim_mark_task_complete.

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

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

The description gives clear context: it is for reopening completed tasks (unarchiving), which implies when to use it. However, it does not explicitly mention alternatives or exclusions, but the opposite sibling (reclaim_mark_task_complete) is obvious 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?

The annotations already signal destructiveness (destructiveHint: true). The description adds the specific side effect of starting time-tracking and the underlying HTTP POST call. However, it does not disclose what happens if the task is already running, error behavior, or other side effects, which would enrich transparency beyond the annotations.

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

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

The description consists of two short sentences, leading with the primary action and including a precise REST endpoint. There is no redundant or extraneous content, making it highly efficient.

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

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

For a simple, single-parameter mutation tool with annotations and full schema coverage, the description is complete enough. It does not explain return values, but the absence of an output schema and the straightforward nature of the operation reduce the need. The sibling tools provide additional context for the workflow.

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 'id' is fully described in the input schema (100% coverage). The description adds no additional parameter semantics, so the baseline score of 3 applies as the schema already carries the burden.

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

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

The description clearly states the action: 'Start time-tracking on a task now', which is a specific verb ('start') + resource ('task'). It also includes the REST endpoint, making it unambiguous and distinct from sibling tools like reclaim_stop_task or reclaim_mark_task_complete.

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

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

The description implies usage—when you want to begin tracking time on a task—but provides no explicit guidance on when to use this tool versus alternatives. It does not mention the counterpart 'stop_task' or any exclusions, leaving usage to be inferred from 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?

Beyond the destructiveHint annotation, the description adds no behavioral context such as idempotency, prerequisites (active timer), or side effects. The REST endpoint is technical but not behavioral.

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 efficiently convey purpose and REST endpoint with no redundant content. Every word earns its place.

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

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

For a single-parameter tool, the description is minimally adequate but lacks return value details and potential error cases. With no output schema, the agent is left without expectations of the response.

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

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

Schema coverage is 100% and describes 'id' as 'The task id to stop.' The description adds no novel parameter information beyond the schema, so a baseline 3 is appropriate.

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

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

Description states 'Stop time-tracking on a task' with a specific verb and resource, clearly distinguishing it from siblings like reclaim_start_task and reclaim_log_work. The REST endpoint further reinforces the exact operation.

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

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

The purpose implies when to use it (to stop time-tracking), but there is no explicit guidance on when not to use it or alternatives (e.g., mark complete). Context is clear but not differentiated from similar actions.

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

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

Annotations flag destructiveHint=true, and the description adds that only provided fields are changed, which is a key behavioral note beyond the annotation. However, it does not cover error handling or side effects such as rescheduling, which would be useful.

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

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

The description is three short, front-loaded segments: purpose, partial-update semantics, and REST mapping. Every sentence adds meaningful information with 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 partial-update operation with full schema coverage and a destructiveHint annotation, the description covers the core behavior. It omits return value and error behavior, which is acceptable given no output schema, but mentioning the response format would make it slightly more complete.

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

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

With schema coverage at 100% for all 10 parameters, the description does not need to re-explain them. It adds no parameter-specific semantics but correctly indicates that only provided fields are changed, which aligns with the schema.

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

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

The description uses the specific verb 'Update' with the resource 'task' and clarifies scope with 'existing task' and 'Only provided fields are changed,' clearly distinguishing it from create/delete/list siblings and naming the REST method.

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

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

The description implies usage as the generic update operation among siblings, but it lacks explicit guidance on when to prefer this over related task-state mutations like mark_complete or start/stop. The partial-update behavior is clarified, but no alternatives are named.

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