Reclaim.ai MCP by usefulapi

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

Annotations already flag destructiveHint=true, and the description adds nothing behavioral beyond a REST endpoint path. Critically, the schema allows negative minutes but the description never explains that negative values effectively remove scheduled time, which is the behavior an agent most needs to know given the destructive hint.

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 front-loaded sentences. The REST endpoint mapping is arguably filler for an agent, but it is compact and does not obscure the core statement.

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 with full schema coverage and no output schema, the essentials are present, but the description omits the one non-obvious behavior: that negative minute values reduce scheduled time (consistent with the destructive hint). That omission is a clear but not fatal gap.

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

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

Schema description coverage is 100%, so both 'id' and 'minutes' are documented in the schema, including the query-param mapping. The description adds no parameter detail beyond what the schema already provides, 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?

States a specific verb ('Add') and resource ('scheduled time to a task'), which is clear enough for an agent to understand the operation. It does not, however, distinguish itself from sibling tools like reclaim_log_work or reclaim_update_task, which could plausibly also alter task time.

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 reclaim_log_work or reclaim_update_task. No prerequisites, no mention that this is a mutation of the task's schedule. The agent must infer the context 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?

The description usefully discloses the automatic calendar-scheduling side effect and the REST endpoint, which is genuine added context beyond the sparse annotations. However, it never explains the destructiveHint=true (what it may overwrite/consume), auth/permission needs, or how scheduling interacts with existing events.

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, front-loaded sentences with no filler; the core purpose leads. The REST endpoint line is slightly low-value for an agent but harmless and does not bloat the text.

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 9-parameter create tool with no output schema and only a destructiveHint annotation, the description leaves the scheduling mechanics (how timeChunksRequired/chunk sizes affect placement, what happens to existing blocks) unexplained. The schema covers parameters, but the auto-scheduling behavior an agent should anticipate is only gestured at.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters including the ISO formats, enums, and chunk semantics. The description adds no parameter-level detail, 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?

States a specific verb+resource ('Create a new task') and adds the key behavioral fact that Reclaim auto-schedules it into the calendar. It is implicitly distinguishable from siblings like reclaim_update_task and reclaim_delete_task, though it never names them 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?

There is no when-to-use guidance and no mention of alternatives. It does not say when to prefer this over update_task or how it relates to add_time/start_task. The only contextual sentence is about scheduling behavior, not selection criteria.

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 destructiveHint=true, so the safety profile is covered by structured data. The description reinforces it with 'Permanently', which usefully signals irreversibility, but says nothing about cascading effects, required permissions, or whether the deletion can be undone.

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 action and its permanence front-loaded. The trailing REST endpoint mapping is toolset boilerplate rather than agent-relevant instruction, but it costs little and is harmless.

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 destructive tool with annotations covering the safety hint and no output schema, the definition supplies everything needed to invoke it correctly. The only real gap is the absence of routing guidance toward reversible alternatives.

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 the single 'id' parameter is fully documented in the schema itself. The description adds no format, source, or constraint detail beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('delete a task') and adds the crucial qualifier 'Permanently', which separates it from reversible siblings like reclaim_mark_task_incomplete or reclaim_update_task. It does not explicitly name those siblings, so differentiation is implied rather than stated.

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 when-to-use guidance, no prerequisites, and never mentions the alternative actions available in this sibling set (mark complete, update, stop). An agent must infer that this is the irreversible option from the word 'permanently' 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the fact that this returns the *authenticated* user and cites the underlying REST endpoint (GET /api/users/me), which confirms it is an auth-scoped read with no parameters — modest added value, but nothing about the response shape or error behavior.

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

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

Two sentences, front-loaded with the operation and followed by the REST mapping. No filler, no restatement 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 no-param identity getter with a readOnly annotation, the essential information is present. With no output schema, the description could say slightly more about what the profile object contains, but nothing needed to invoke the tool correctly 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?

Zero parameters, so there is nothing to document and no ambiguity to resolve; baseline 4 applies. The description correctly signals that no inputs are needed by describing the operation as retrieval of the caller's own profile.

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

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

States a specific verb ('Get') and resource ('the authenticated Reclaim user's profile'), which no sibling tool covers — all siblings operate on tasks, habits, or events. An agent can identify this as the identity/account lookup without opening the schema.

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 rather than stated: it retrieves the caller's own identity, so there is no alternative to weigh. The description offers no explicit when-to-use trigger (e.g., 'use this to resolve the current user's ID before other calls'), which would have helped, but the absence of competing siblings keeps this from being a real ambiguity.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the REST provenance (GET /api/assist/habits/daily/{id}), which helps agents correlate with the API, but says nothing about error behavior when the id is unknown or what the returned habit contains.

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

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

Two short sentences, front-loaded with the purpose before the API mapping. Nothing is padded, though the bare REST path is of marginal use to an agent and is the only content after the core statement.

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 read tool whose annotations cover safety, this is nearly adequate. However, with no output schema, the description could have described the shape of the returned habit, and it offers no guidance on missing/unknown ids.

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

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

Schema description coverage is 100% and there is a single required parameter, so the schema already documents 'id' fully. The description adds no format, sourcing, or constraint detail beyond what the schema states, making the baseline 3 appropriate.

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

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

States a specific verb and resource ("Get a single daily habit by id") and the singular scope implicitly distinguishes it from the sibling reclaim_list_habits. No sibling tool is named, so differentiation rests on inference rather than explicit contrast.

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 never says when to use this tool versus reclaim_list_habits, nor does it state prerequisites such as needing a previously obtained habit id. Only the phrase "by id" hints at the required context; there is no explicit when-to-use or exclusion 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?

Annotations already declare readOnlyHint=true, so the safe read nature is carried by structured data. The description adds only the REST endpoint correspondence (GET /api/tasks/{id}), no return shape or error behavior. With annotations covering safety, a 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 with the purpose front-loaded and zero padding. The REST mapping is a minor value-add rather than waste. Slightly more terse than necessary but well structured.

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

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

For a single-resource read with one fully documented parameter and no output schema, the definition is minimally sufficient. It gives no indication of what the returned task contains or how errors (e.g. unknown id) surface, but the low complexity limits the practical risk.

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

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

Schema description coverage is 100% (the id parameter is documented as 'The task id.'), so the schema does the heavy lifting. The description adds no format, type, or sourcing detail for the id beyond what the schema provides, 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?

States a specific verb (Get) and resource (task) with explicit scope (single, by id), which clearly separates it from the sibling list_tasks. The REST endpoint mapping reinforces the operation. It stops short of explicitly naming the sibling alternative, so not 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?

Usage is implied: fetch one task when you have its id. There is no explicit when-to-use statement, no exclusion of list_tasks, and no mention of prerequisites. Adequate but with a clear gap.

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?

readOnlyHint=true already tells the agent this is a safe read. The description contributes only the endpoint path and the optional-window note, with no mention of result ordering, pagination, caps, or default time range for a list endpoint where those traits matter.

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 terse fragments, front-loaded with the core purpose and free of filler. Slightly telegraphic – the fragments read as note stubs rather than sentences – but 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 two-optional-param read tool with annotations and full schema coverage, the minimum is met, but absence of any default-window or return-shape note leaves the agent guessing about what a windowless call returns. No output schema exists, so a brief return summary would have helped.

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 both parameters are fully documented in the schema, including that they map to ISO date/datetime query params. The description's 'Optional start/end window' merely restates the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('List calendar events') and disambiguates from siblings list_tasks/list_habits by naming events explicitly. The REST endpoint reference reinforces the resource but adds nothing that helps selection.

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?

Only 'Optional start/end window' hints at usage; there is no when-to-use guidance, no mention of what happens with an omitted window (all events? default range?), and no routing to or from sibling tools like get_task or list_habits.

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 establishes this is a safe read. The description adds the useful scoping detail that results are limited to the authenticated user's own daily habits, plus the REST endpoint mapping. It still says nothing about ordering, pagination, or volume, which are the traits a listing tool would benefit from disclosing.

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, zero padding, with the core purpose front-loaded and the endpoint mapping relegated to a short trailing clause. Nothing could be removed without losing 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?

For a parameterless, read-only list operation, the definition covers what an agent needs to decide to call it. Since there is no output schema, a brief note on what a habit record contains would have made it fully self-contained, but that 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 takes zero parameters, so there is no parameter semantics to document and the baseline is 4. The description correctly implies no filtering input exists by describing a simple current-user listing.

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 ('List the authenticated user's daily habits'), which is unambiguous and scopes the result to the current user's daily habits. It does not explicitly contrast with the sibling reclaim_get_habit, but the plural 'list' vs. singular retrieval distinction is clear enough from the verb 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?

Usage is only implied: listing habits is the natural read operation, and the phrase 'daily habits' hints at the resource subset. There is no explicit statement of when to prefer this over reclaim_get_habit, nor any precondition or exclusion noted.

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?

readOnlyHint=true already tells the agent this is a safe, non-mutating read, so the description only needs to add context. It contributes the scope ('authenticated user's') and the underlying GET /api/tasks endpoint, but says nothing about pagination, result limits, or ordering.

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 zero waste; the purpose statement is front-loaded and the endpoint mapping is a compact, useful second clause.

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

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

For a zero-parameter, read-only list tool the description covers the essentials, and annotations carry the safety profile. Minor gap: with no output schema, it could hint at the shape or volume of returned tasks.

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 per the baseline there is nothing for the description to disambiguate. The absence of any filter arguments is implicitly consistent with the 'list all tasks' claim.

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

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

States a specific verb and resource ('List the authenticated user's tasks') and the backing REST call, so the agent knows exactly what it returns. It does not, however, explicitly distinguish itself from sibling reclaim_get_task or reclaim_list_habits.

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: the agent can infer this is the bulk-listing counterpart to the single-item reclaim_get_task. There is no explicit when-to-use, when-not-to-use, or mention of alternatives.

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

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

Only annotation is destructiveHint=true, and the description adds nothing about side effects: whether logging work mutates the task's tracked/remaining time, whether it overwrites existing entries, what happens if minutes is negative, or permission needs. For a mutation tool flagged destructive, that is a substantial disclosure 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?

Two short sentences, front-loaded with the action and free of filler. The REST endpoint detail is compact and operationally useful, though slightly redundant with the tool name.

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

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

For a 3-parameter mutation tool with no output schema and only a destructiveHint annotation, the definition covers the basics but omits return behavior and the effect of logging work on the task, forcing the agent to guess at consequences.

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 each parameter has its own description, including the query-param mapping, so the schema does the heavy lifting. The description adds no parameter meaning beyond that, which is the expected baseline.

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

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

Clear specific verb and resource: 'Log completed work time against a task.' The REST endpoint line reinforces scope. It does not, however, explicitly differentiate from the sibling reclaim_add_time, which an agent would likely 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?

No when-to-use, when-not-to-use, or prerequisite guidance. The most obvious ambiguity — this tool vs reclaim_add_time, or vs reclaim_start_task/reclaim_stop_task — is left entirely to inference.

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

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

The annotation already declares destructiveHint=true, so the agent knows this mutates state destructively; the description adds the REST endpoint mapping, which is useful diagnostic context. It does not disclose side effects (e.g., whether an in-progress timer is stopped, whether the completion is reversible), so it adds only modest value beyond the annotation.

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 semantic action before the API detail. The endpoint sentence is marginally redundant but plausibly useful for a Reclaim-integration agent; nothing is bloated.

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

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

For a single-parameter mutation with an annotation covering destructiveness and no output schema, the description is largely sufficient. The only material gap is side-effect behavior (timer interaction, reversibility) that an agent might want before invoking a destructive 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?

There is a single required parameter with 100% schema description coverage ('The task id to mark complete'), so the schema already carries the parameter burden. The description adds nothing beyond that, which matches the baseline of 3 when schema coverage is high.

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+resource ('Mark a task as done in the planner') and even names the underlying REST endpoint, so the agent knows exactly what operation this performs. It does not explicitly contrast with the near-identical sibling reclaim_mark_task_incomplete, which keeps it from a 5.

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

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

There is no statement of when to use this tool versus alternatives such as reclaim_mark_task_incomplete, reclaim_stop_task, or reclaim_update_task, nor any prerequisites or exclusions. Usage can only be inferred from the verb itself.

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 flag destructiveHint=true, so the mutation risk is communicated structurally. The description adds the state transition (reopen/unarchive) and the POST endpoint, which confirms a write. It does not disclose side effects such as whether completion timestamps, archive status, or reporting history are affected.

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 operation and its purpose. The REST endpoint line is conventional filler for this tool family rather than information an agent needs to choose the tool, but it is brief and does no harm.

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 one-parameter, no-output-schema tool with annotations covering the safety profile needs little prose; the description covers what the operation does and how it is invoked. The only real gap is the absence of routing guidance versus sibling task-mutation tools.

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

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

Schema description coverage is 100% and the single 'id' parameter is documented in the schema itself ('The task id to mark incomplete'). The description only echoes the id via the URL template and adds no format or constraint detail, 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?

States a specific verb ('Reopen') and resource ('a completed task') with a clarifying synonym ('unarchive') and the backing REST endpoint. It is effectively the inverse of reclaim_mark_task_complete, but that sibling is never named, so differentiation is inferential rather than explicit.

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 'Reopen a completed task' implies the precondition (the task must be completed/archived), which is reasonable implied usage. However, no alternative tools are named and no when-not guidance is given (e.g., what to do for a task that was never completed, or how this differs from reclaim_update_task or reclaim_delete_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?

Annotations declare destructiveHint=true, which is counterintuitive for a 'start' operation, yet the description never explains what is destroyed or overwritten (e.g., whether an in-progress timer on another task is stopped). It adds the REST endpoint mapping, which is useful, but omits the side-effect context the destructive hint demands.

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 followed by the API mapping; nothing is padded. The only minor redundancy is restating the title's 'Start task' concept.

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 with no output schema, the description covers the action and endpoint adequately. It remains incomplete about side effects implied by destructiveHint=true, which matters for a start action that may displace an existing running timer.

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?

Only one parameter (id) exists and schema coverage is 100%, so the schema fully documents it; baseline is 3. The description adds nothing beyond what the schema already states ('The task id to start'), though the REST path {id} mildly reinforces 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?

States a specific verb+resource ('Start time-tracking on a task') clearly enough that an agent can distinguish it from stop_task or mark_task_complete. It does not explicitly name the sibling it diverges from (e.g., log_work for retroactive entries), so it stops short of full differentiation.

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

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

The word 'now' hints at real-time tracking versus logging past work, but there is no explicit when-to-use, when-not-to-use, or named alternative (log_work, add_time, stop_task). The agent must infer the choice among several related siblings from their names 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?

Annotations already declare destructiveHint=true, so the mutating nature is covered. The description adds only that the target is time-tracking and the underlying POST endpoint; it says nothing about side effects, what happens if the task is not currently being tracked, or reversibility. Adequate but thin given annotations already carry the main signal.

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 action front-loaded and no filler. The REST endpoint sentence is marginally useful for traceability but is the weakest element of an otherwise tight definition.

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 tool with annotations covering the destructive hint and no output schema, the description supplies what is needed to invoke it correctly. Minor gaps remain around behavior when no timer is active, but nothing essential 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?

Only one parameter exists and schema description coverage is 100%, so the schema fully documents 'id'. The description adds no format, source, or lookup guidance for the id, so the baseline 3 applies.

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

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

States a specific verb and resource ('Stop time-tracking on a task'), which cleanly distinguishes it from the sibling reclaim_start_task. It stops short of naming that sibling or any other alternative, so it is clear but not maximally differentiating.

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 applies when a timer is currently running on a task, but the description gives no explicit when-to-use, when-not-to-use, or pointer to reclaim_start_task / reclaim_log_work. The REST endpoint line adds no 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 annotations supplying destructiveHint=true, the description adds a genuinely useful behavioral detail — 'Only provided fields are changed' — clarifying partial-update semantics. It does not, however, explain what the destructive flag implies for this tool, whether changes are reversible, or any auth requirements, so it only modestly exceeds the annotation baseline.

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 core action, with the partial-update rule immediately following. The REST mapping is compact and useful; no filler, though it could be tightened to two sentences without loss.

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 10-parameter mutation tool with no output schema, the description covers the essential partial-update behavior and endpoint, and the schema carries the parameter detail. It stops short of explaining the destructive nature of the operation or any side effects, which an agent should know before mutating a task.

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

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

Schema description coverage is 100%, so every parameter including enums (priority, eventCategory) and chunk-size fields is already documented. The description adds only the general rule that unspecified fields are left unchanged, which is a semantic clarification rather than per-parameter detail; 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?

States a specific verb and resource ('Update fields on an existing task'), and the PATCH reference reinforces the partial-update meaning. It does not explicitly differentiate from siblings like reclaim_create_task or reclaim_mark_task_complete, but the update semantics are unambiguous from the name and 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?

Usage is implied rather than stated: an agent can infer this is for modifying an existing task by id, and that create/delete siblings are for other operations. There is no explicit 'use this when... instead of...' routing guidance and no prerequisites such as required permissions or a valid existing task id.

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