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

With no annotations provided, the description must convey behavioral traits. It says 'Accept' which implies a mutation, but it does not disclose what happens to the request (e.g., status change, user membership), whether the caller must be an admin/owner, or any side effects. This is a significant gap 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?

The description is a single sentence with no wasted words, making it highly concise. However, its brevity contributes to under-specification for a mutation tool, though conciseness alone is appropriate.

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

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

For a one-parameter tool with an output schema, the description lacks critical context about consequences (e.g., what happens after acceptance), required roles, or relationship to other tools like get_join_requests. It is not complete for an agent to safely invoke without 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 coverage is 100% and the parameter 'request_id' has a description ('The ID of the join request'). The tool description adds no extra meaning beyond what the schema already provides, so it meets the baseline of 3.

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

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

The description states 'Accept a pending circle join request', which is a clear verb+resource pairing that indicates the action. It distinguishes from sibling tools like get_join_requests (which lists) and join_circle (which initiates a request), but does not explicitly call out 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?

No guidance is given on when to use this tool versus others. There is no mention of prerequisites like listing pending requests via get_join_requests or checking permissions before accepting. The description only states the action without any context or exclusions.

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

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

There are no annotations provided, so the description carries the full burden of behavioral disclosure. It mentions 'requires approval', hinting at a permission requirement, but does not disclose what happens after approval (e.g., state change, points awarded, irreversibility). The description is minimal and does not clarify whether approval can be undone or what the effect on the chore status is. This is a significant gap for a state-changing action.

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

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

The description is a single, concise sentence that is easy to parse. It is front-loaded with the core action ('Approve a pending chore completion') and includes a parenthetical clarifying requirement. There is no wasted content, though it could benefit from a bit more detail without being verbose.

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?

While the tool has a simple schema and an output schema, the description is very brief for an action that modifies state. Without annotations, the description should provide more context about the workflow, such as what constitutes a 'pending chore completion', whether approval is reversible, and what the expected outcome is. Sibling tools like 'reject_chore' and 'undo_chore' imply a complex state machine, and the description does not help the agent understand where this fits in that flow.

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 provides 100% description coverage for the single parameter 'chore_id', which is clearly described as 'The ID of the chore'. The description adds no additional meaning beyond that, but since the schema already fully covers the parameter, a baseline of 3 is appropriate. The description does not clarify if the chore must be in a specific state (e.g., pending completion) for the approval to be valid, which could be useful, but schema coverage is complete.

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

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

The description clearly states the tool's purpose: approving a pending chore completion. It uses a specific verb ('approve') and resource ('chore completion'), distinguishing it from siblings like 'reject_chore' or 'complete_chore'. However, it doesn't explicitly differentiate from 'undo_chore' or 'archive_chore' which might also affect chore state, but the primary function is clear.

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 in a workflow where a chore completion is pending and requires approval, but it doesn't explicitly state when to use this tool versus alternatives like 'reject_chore' or when not to use it. It provides some context with '(requires approval)' but lacks explicit alternatives or exclusion criteria. Sibling tools like 'reject_chore' suggest a decision flow, but this is not stated.

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

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

No annotations are provided, so the description must carry the burden. It discloses the primary effect (moves out of active list), but does not mention reversibility (though unarchive_chore exists as sibling), impact on history, or any side effects. Minimal but not misleading.

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 sentence, clear, no fluff.

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

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

Simple tool with one parameter and output schema present, but no usage context or prerequisites. Lacks mention of reversibility or relationship to unarchive_chore, which is a sibling tool. Could be more complete.

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

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

Schema covers 100% of the parameter (chore_id) with its description. The tool description adds nothing beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states 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 on when to use this tool versus alternatives like delete_chore, pause_chore, or unarchive_chore. The description does not provide exclusions or context for choosing this over siblings.

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

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

No annotations are provided, so the description must disclose behavioral implications. It only states the mutation (changing a role) but fails to mention side effects, permission requirements, reversibility, or any constraints (e.g., cannot demote the last admin). This is a significant gap for a state-changing 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?

The description is a single, concise sentence that includes the essential action and the valid role options. There is no redundant wording or unnecessary detail, 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 role-change tool with two parameters fully documented and an output schema present, the description is minimally sufficient. However, it lacks context about prerequisites (e.g., admin permissions) and potential restrictions, which could be important for correct invocation in complex scenarios.

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 both parameters (member_id and role), and the description adds no extra meaning beyond listing the allowed role values, which are already in the schema. With 100% schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the action ('Change a circle member's role') and specifies the resource (circle member) plus the valid values (admin, member, or manager). It is specific enough to distinguish from sibling tools like delete_circle_member or get_circle_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?

No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without mentioning any exclusions or conditions, such as 'Use this to update roles, not to remove members.'

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

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

With no annotations, the description carries the burden. It clearly states the mutation action and the two modes but does not disclose behavior when both parameters are provided, potential side effects, or error conditions. The output schema exists, which may cover response structure, but the description omits edge-case behavior.

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

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

The description is extremely concise yet informative—two sentences front-load the core action and immediately explain the two operational modes. Every word earns its place, with no redundant or tangential 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?

Given the presence of an output schema, 100% parameter documentation, and a simple operation, the description adequately covers the essential behavior. It explains the two ways to modify state, meeting the needs for typical use. Minor gaps like interactions when both parameters are set are not covered but are not critical for this simple tool.

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

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

Schema description coverage is 100%, so the schema already defines each parameter fully. The description merely rephrases the same information (set_value = new direct value, op = signed integer to add). It adds no new meaning beyond what the schema provides, meriting the baseline score for high coverage.

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

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

The description clearly specifies the action (change state) and the two distinct methods (direct set via set_value or incremental via op). It distinguishes this from sibling tools like get_thing_state (read) and update_thing (broader updates) by focusing solely on state modification.

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 explains the two parameter usage patterns ('set directly' or 'add a signed integer') but does not explicitly guide when to choose this tool over alternatives such as update_thing. It implies use for state-only changes but lacks explicit exclusions or alternative suggestions.

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

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

With no annotations, the description carries the full burden of explaining side effects, permissions, or return values. It only states the action with no information about what happens after completion, whether the chore is deleted or archived, or if any confirmation or output is returned.

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

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

The description is a single, concise sentence with no unnecessary words or redundancy. It is well-structured and directly communicates the core action without clutter.

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 (two parameters, no output schema), but the description does not explain what happens after completion, whether there are any side effects (e.g., auto-archive, point redemption), or what the tool returns. This leaves gaps for users understanding the full impact, especially given that sibling tools like 'approve_chore' and 'redeem_points' suggest a more complex 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?

Both parameters have clear descriptions in the schema. 'chore_id' identifies the target chore, and 'completed_by' specifies the user (optional). The descriptions are sufficient for understanding the inputs, though they lack details about defaults or validation.

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 chore as complete') with a clear verb and object. However, it does not explicitly differentiate its purpose from similar chore-related actions like 'approve_chore' or 'undo_chore', which could cause ambiguity in certain workflows.

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 compared to alternatives such as 'start_chore', 'approve_chore', or 'undo_chore'. There is no mention of prerequisites, whether it applies to individual or bulk chores, or if it should be used in specific sequences.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'create a new chore' without detailing potential side effects, required permissions, reversibility, or other behavioral traits. This is insufficient for a mutation operation, especially since no prerequissite or auth information is given.

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

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

The description is a single short sentence with no extraneous words, which is appropriately concise for this simple create operation. However, it could include a bit more context (e.g., typical usage or required fields) without becoming verbose, so it loses one point for being somewhat underspecified.

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

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

Given the tool has 5 parameters (all optional except name) and an output schema exists, the description should provide at least some context about the creation process or prerequisites. It does not mention required fields, possible duplicate handling, or the fact that the name is mandatory. The output schema covers return values, but the description lacks overall completeness for a create 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 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides for each parameter. Since the schema fully documents parameters, the tool earns the baseline without needing compensation from the 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 the action verb 'Create' and the resource 'a new chore in Donetick', which specifically differentiates it from sibling tools like update_chore, delete_chore, etc. It leaves no ambiguity about the tool's core purpose.

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 creating a new chore, but it does not provide explicit guidance on when to use this over alternatives like update_chore or create_project. No exclusions or alternative recommendations are mentioned, leaving the decision to the agent's inference from the tool name.

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

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

No annotations are provided, so the description carries the full responsibility for disclosing behavior. It only says a project is created and does not mention side effects, authorization requirements, idempotency, default behaviors for omitted fields, or what happens if a duplicate name is provided.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is appropriately concise, though it mostly restates the tool title and does not contribute any additional contextual value beyond the obvious action.

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 create operation with fully documented parameters and an output schema, the core intent is conveyed sufficiently. However, the lack of usage context and behavioral detail leaves an agent without enough information to confidently select this tool over alternative create operations.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters. The description adds no parameter-level meaning, but the complete schema coverage makes this acceptable under the baseline.

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

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

The description clearly states the action ('Create') and the resource ('a new project'), immediately distinguishing it from sibling create_chore and create_thing tools. Although minimal, it is precise and unambiguous about what the tool does.

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

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

No guidance is provided about when to use this tool versus related tools such as create_chore, create_thing, or update_project. There are no conditions, prerequisites, exclusions, or alternative pointers to help an agent decide when this is the correct choice.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Create a new thing', implying a mutation, but does not mention any side effects, authentication requirements, idempotency, or what happens to existing data. The absence of any behavioral details is a significant gap.

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

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

The description is a single concise sentence that instantly conveys the core purpose. It is front-loaded and contains zero filler, 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?

Given that the tool has an output schema and a well-documented input schema, the description is not required to explain return values. However, it lacks any contextual details such as prerequisites or typical use cases. For a simple create operation, this is adequate but not exhaustive.

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

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

The input schema has 100% description coverage for all three parameters, so the schema already documents them thoroughly. The description adds no additional parameter explanation, but the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the action (create) and the resource (thing), with an added parenthetical 'trackable value' that adds meaning. It distinguishes itself from sibling tools like create_chore and create_project by explicitly naming 'thing'.

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 usage is implied by the name and description — if you need to create a thing, this is the tool. However, there is no explicit guidance on when to use this versus update_thing or other create tools, and no mention of when not to use it.

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

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

With no annotations, the description carries the burden of exposing destructive behavior. It clearly states the deletion is permanent and adds the creator-only authorization rule. It could mention what happens to associated data or history, but it is reasonable for a simple 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?

Two short, focused sentences with the core action front-loaded and no redundant details. 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?

Given the tool's simplicity, one required parameter, and existing output schema, the description fully covers the core semantics: what is deleted, whether it is reversible, and who is authorized to do 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?

The schema already describes chore_id as 'The ID of the chore to delete.' The description adds no extra parameter-level meaning, and with 100% schema coverage, it doesn't need to do much more.

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 the exact operation: 'Delete a chore permanently.' and names the resource. This clearly distinguishes it from siblings like archive_chore, pause_chore, complete_chore, and update_chore.

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 clear context about who may use the tool: 'Only the chore creator can delete a chore.' It does not explicitly mention alternatives such as archiving a chore, so it slightly misses full when-not guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action, omitting potential side effects (e.g., cascade deletions, permission requirements, reversibility) and any consequences for the removed member within the circle 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?

The description is a single sentence with zero filler, immediately front-loading the primary action and object. It is as concise as possible while remaining meaningful.

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 simple schema and low complexity, the description omits critical context for a destructive mutation: no mention of effects on related data, no prerequisites, no behavioral caveats. An output schema exists but is not shown, so the description still leaves the agent guessing about operational impact.

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 a clear parameter description ('member's user ID'). The description adds no extra semantic meaning but doesn't need to, as the schema adequately documents the only 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 uses a specific verb ('remove') and resource ('member from the circle'), making the action unambiguous. It clearly distinguishes from sibling tools like leave_circle (self-removal) and change_member_role.

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

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

No guidance is provided on when to use this tool vs alternatives, prerequisites, or contextual triggers. The description is purely declarative and offers no practical usage cues.

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 disclosing behavioral traits. The word 'permanently' indicates irreversibility, but it does not elaborate on cascading effects (e.g., related tasks, subtasks), permission requirements, or confirmation steps. Without annotations, this is insufficient transparency 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?

The description is a single, concise sentence that is front-loaded with the core action and its most critical implication ('permanently'). There is zero redundancy or filler, making it highly efficient for an agent to quickly grasp the tool's 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?

Given the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description could be minimal. However, the lack of annotations and the absence of any behavioral context (e.g., irreversibility consequences, side effects, prerequisites) makes it incomplete for a destructive operation. Even a simple delete would benefit from a note about what happens to related data or any safeguards.

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

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

The schema fully documents the single parameter 'project_id' with a clear description ('The ID of the project'), so schema coverage is 100%. The tool description adds no additional semantic meaning beyond what the schema already provides, meeting the baseline for high coverage without enhancement.

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 'Delete a project permanently' clearly states the action (delete), the target resource (project), and adds the crucial qualifier 'permanently', distinguishing it from any potentially reversible delete operations. This is specific and unambiguous, and it clearly contrasts with sibling tools for other resources like delete_chore or delete_thing.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there any prerequisites or exclusions. The description is a bare statement of action without context about scenarios where deletion might be discouraged or require confirmation. There is no mention of alternatives, such as archiving, which appears among sibling tools.

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

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

With no annotations, the description carries the full burden. The word 'permanently' discloses irreversibility, but there is no mention of side effects, permissions, or return behavior. This is only partial transparency 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?

The description is a single, front-loaded sentence: 'Delete a thing permanently.' It contains no fluff or redundant information, making it an efficient and well-structured specification.

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

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

For a simple delete operation with a fully documented parameter and an output schema, the description is adequate but sparse. It lacks behavioral details like the possibility of cascading deletes, undo options, or permission requirements, which would be important for an agent to fully understand the operation's 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?

The input schema already provides complete coverage of the single parameter 'thing_id' with its type and description. The description adds no additional parameter-level semantics beyond what the schema offers, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Delete') and resource ('a thing') with the adverb 'permanently,' clearly distinguishing this tool from update_thing or change_thing_state. It unambiguously states the operation's scope.

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

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

No guidance is provided regarding when to use this tool versus alternatives like update_thing or change_thing_state. The description does not include exclusions, prerequisites, or context for decision-making.

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 for behavioral disclosure. It does mention pagination, which is a useful behavioral trait, but does not specify ordering, inclusion criteria (e.g., only successful completions), authentication needs, or potential side effects. 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 efficient sentence that front-loads the action and scope. Every word contributes value, with no redundancy or filler.

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

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

For a simple paginated list tool with an output schema, the description is nearly complete. It covers the core functionality and pagination, and the schema handles parameter details. However, it could explicitly note the contrast with single-chore history tools, though this is inferred from the name and sibling context.

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

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

The schema already describes both limit and offset with defaults and constraints (100% coverage). The description's mention of 'pagination' merely echoes these parameters without adding new semantic meaning, so it remains at the baseline for schema-covered parameters.

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

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

The description clearly states the tool's function: 'Get completion history for all chores' with pagination. The verb 'get' and resource 'completion history' are specific, and the qualifier 'all chores' distinguishes it from sibling tools like get_chore_history that likely target a single chore.

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 all chores' provides clear context for when this tool should be used (bulk history), implicitly distinguishing it from get_chore_history for a single chore. However, it does not explicitly name an alternative or include exclusions, so it falls short of the highest 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 provided, the description carries the full burden of behavioral disclosure. It merely implies a read operation ('get details') but reveals nothing about error behavior for invalid IDs, permission requirements, return format, or scope of 'details.' This falls short for a tool with zero annotation coverage.

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

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

The description is a single, clear sentence with zero wasted words. It states the action, resource, and qualifier 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 1-parameter read tool with an output schema present, the description is minimally adequate since return values needn't be explained. However, it does not address the ambiguity with the get_chore_details sibling or note any special behavior, leaving it slightly incomplete for the tool's 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?

Schema description coverage is 100% (chore_id is documented as 'The ID of the chore to retrieve'), so the schema carries the parameter meaning. The description's 'by its ID' phrase only restates this without adding format, requirements, or edge-case details, matching the baseline for full schema coverage.

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

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

The description clearly states a specific verb ('get') and resource ('chore') with a scope qualifier ('by its ID'), which distinguishes it from list_chores. However, it fails to disambiguate from the close sibling get_chore_details, which sounds functionally equivalent, so it doesn't fully differentiate within the sibling set.

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 usage guidance is provided. The description contains no when-to-use, when-not-to-use, or alternative tool mentions. Given the crowded chore namespace (with get_chore_details, list_chores, get_chore_history), there is no direction on when this tool is the right choice over siblings.

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. 'Get' implies a read-only operation and the addition of 'completion statistics' adds context, but it doesn't mention error behavior, permissions, or side effects. For a simple retrieval this is adequate but minimal.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose with no wasted words. It earns its place.

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

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

The tool is relatively simple with one parameter and an output schema, but the description doesn't clarify when to use this over get_chore or get_chore_history. Lacking annotations, the one-sentence description leaves some contextual gaps.

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

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

The schema fully describes the single parameter (chore_id as 'The ID of the chore to fetch detailed statistics for') with 100% coverage. The description adds no parameter-level information, so baseline 3 is appropriate.

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

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

The description clearly states a verb+resource: 'Get detailed chore information including completion statistics.' It distinguishes from sibling get_chore implicitly by adding 'detailed' and 'statistics', but doesn't explicitly name the 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 implies this tool is for fetching detailed stats, but provides no explicit guidance on when to use it instead of siblings like get_chore or get_chore_history. There are no exclusions or alternatives 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?

With no annotations provided, the description carries the full burden of disclosing behavior. 'Get completion history' implies a read-only operation, but it does not explain what events are included, whether results are ordered, if pagination exists, or whether the call has side effects.

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

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

The description is a single front-loaded sentence with a clear verb, resource, and scope. Every word contributes meaning, and there is no redundancy or filler.

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

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

For a simple tool with one fully documented parameter and an output schema, the description covers the core operation adequately. However, it lacks differentiation from sibling history/detail tools and provides minimal behavioral context, leaving some selection ambiguity for an AI agent.

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

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

The schema has 100% description coverage for the single parameter, so the schema already explains chore_id. The description adds no additional semantic meaning beyond what is already in the schema.

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

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

The description uses a specific verb ('Get') and resource ('completion history for a specific chore'), which is clear. It implicitly distinguishes from get_all_chores_history by targeting a single chore, though it doesn't explicitly contrast with sibling tools like get_chore_details.

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

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

There is no guidance on when to use this tool versus alternatives such as get_all_chores_history or get_chore_details. The intended use case is implied but never explicitly stated, and no exclusions or prerequisites 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?

With no annotations, description must carry transparency burden. 'Get' implies a read-only operation and the parenthetical scopes the resource, but it doesn't disclose whether membership/role is required, whether the current circle is inferred, or any other operational context. It is not misleading, but adds only minimal 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?

Single sentence, no redundancy, front-loaded with the action and resource; parenthetical earns its place by disambiguating domain vocabulary.

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, a true output schema, and a simple getter operation, the one-sentence description is mostly sufficient. The main gap is not explicitly saying 'current' circle, but the low complexity and output schema mitigate that.

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 zero parameters, so the baseline is 4. The description adds no parameter semantics, but none are needed; the only implicit semantic is the circle scope.

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 uses a specific verb-resource pair ('Get all members') and adds a clarifying parenthetical defining circle as household/team. Clearly targets member listing rather than sibling operations like list_circles or delete_circle_member.

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

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

No when-to-use or when-not-to-use guidance and no alternatives are named; the only cue is the tool name and the phrase 'in the circle.' It fails to state that this operates on the current/selected circle or distinguish from member-management siblings.

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

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

With no annotations, the description must carry the full burden. The verb 'list' implies a safe, read-only operation, but it does not explicitly disclose any behavioral traits like pagination, ordering, or the absence of side effects. The description is adequate but lacks explicit safety confirmation.

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

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

The description is a single sentence that is direct and front-loaded with the key action and resource. It contains no wasted words and is immediately usable.

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

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

Given the tool's simplicity (no parameters) and the presence of an output schema, the description covers the essential purpose. It could provide more contextual guidance, such as typical usage scenarios or that it returns a list of members waiting approval, but the current description is sufficient for a simple list 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?

There are zero parameters, so the description does not need to add parameter details. The schema is empty, and the description adds no unnecessary information, making a baseline score of 4 appropriate.

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

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

The description uses a clear verb 'list' and a specific resource 'pending join requests' for 'the circle', which distinguishes it from sibling tools like accept_join_request or list_circles. It explicitly scopes to pending requests, leaving no ambiguity about its function.

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 suggesting it before accepting a request or noting it as a read-only view. The description only states the action without context on its role in workflows.

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

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

There are no annotations, so the description carries the burden of indicating side effects. The verb 'Get' implies a read-only operation, but the description does not explicitly state that it is non-mutating, mention error handling (e.g., not found), or describe what data is returned beyond the existence of an output schema.

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

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

The description is a single sentence that directly conveys the essential operation. Every word earns its place, with no redundancy or filler.

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

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

For a simple get-by-ID tool with an output schema and one parameter, the description is minimally adequate. However, it does not address the presence of closely related sibling tools (e.g., get_thing_state, get_thing_history), leaving potential ambiguity about when to invoke this specific tool.

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

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

The schema already documents thing_id with 100% coverage, including its type and description. The description's 'by its ID' adds no meaning beyond what the schema already provides, matching the baseline for high schema coverage.

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

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

The description clearly states a specific verb ('Get') and resource ('a thing by its ID'), making the core purpose understandable. However, it does not distinguish it from sibling tools like get_thing_state or get_thing_history, which could also retrieve data about a thing.

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

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

No guidance is provided on when to use this tool versus alternatives such as list_things, get_thing_state, or get_thing_history. The description offers no contextual cues or exclusions to help an agent choose among the many sibling tools.

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

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

With no annotations provided, the description must disclose behavioral traits. It only states 'state-change history' without explaining what that includes (e.g., timestamps, ordering, granularity), side effects, or required permissions. It is minimal and does not convey enough beyond the tool's name.

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

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

The description is a single sentence that is concise, front-loaded, and contains no filler. Every word earns its place, and it is appropriately sized for a simple tool.

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

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

The tool is simple with one parameter and an output schema present (which handles return values). However, the description is sparse; it doesn't clarify what a 'state-change history' entails (e.g., chronological list, included fields). While not fatally incomplete, it leaves the agent to infer details that could be stated briefly.

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 parameter 'thing_id' is described as 'The ID of the thing' in the schema. The tool description adds no additional meaning to the parameter, so it meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool gets a thing's state-change history, using a specific verb and resource. It is easily distinguished from sibling tools like get_thing (current state) and get_thing_state (likely current state only), and from chore history tools. No ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_thing, get_thing_state, or change_thing_state. There is no mention of use cases, prerequisites, or exclusions, leaving the agent to infer usage 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 full burden of behavioral disclosure. It simply restates the obvious 'get current state' without mentioning read-only nature, potential errors, or any side effects. It adds no information beyond the tool name.

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

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

The description is extremely short (one sentence), but it is under-specified rather than concise. It restates the tool's purpose without offering additional value, similar to a tautology. It is front-loaded but lacks substance.

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

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

For a tool with no annotations and a single parameter, the description provides no context about return format, error conditions, or relationship to other tools. Although an output schema exists, the description does not leverage it or add any contextual value. It is incomplete for an agent to fully understand behavior.

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

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

The schema covers 100% of the single parameter (thing_id) with a description, so the baseline is 3. The tool description does not add any additional semantics or context about the parameter beyond what the schema already provides.

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

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

The description 'Get the current state of a thing' clearly states the action (get) and the resource (state of a thing). It distinguishes from sibling tools like get_thing and update_thing_state by focusing specifically on retrieving the state. However, 'thing' is generic and could be more specific, but within context it is adequate.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_thing or get_chore_details. There are no examples of typical use cases or exclusions. The description alone does not help the agent decide between tools.

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

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

No annotations are provided, so the description must carry the transparency burden. It only states the action and prerequisite; it does not disclose auth requirements, effects on membership, error behavior for invalid codes, or reversibility.

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, front-loaded action and parameter. Every word earns its place.

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

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

For a simple one-parameter operation with an output schema, the description captures the core action and input. It lacks some behavioral nuance, but the low complexity and complete schema make this adequate.

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

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

Schema description coverage is 100% for the single invite_code parameter, so the schema already documents it. The description repeats 'invite code' without adding format, source, or validation details; 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?

Description uses a specific verb ('Join') and resource ('circle'), and specifies the mechanism ('with an invite code'). This clearly distinguishes it from sibling circle-management tools like accept_join_request and leave_circle.

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 'with an invite code' implies the intended use case, but the description does not explicitly state when to choose join_circle over related tools or mention exclusions. There is no guidance about the request-approval flow or when an invite code is required.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. 'Leave the current circle' reveals only the high-level intent, but says nothing about whether the action is reversible, what side effects occur (e.g., data loss, notifications), or what 'current' means in context. The description adds no behavioral context beyond the tool's name.

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

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

The description is a single, tight sentence that front-loads the action and uses every word. There is zero wasted length and no 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 zero-parameter action with an output schema, the description is minimally viable, but it doesn't hint at the return value, clarify the ambiguity with delete_circle_member, or explain the 'current' concept. It's adequate for a simple tool but leaves meaningful gaps.

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

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

The tool accepts zero parameters and schema description coverage is at 100%, so there are no parameter semantics to document. The description need not add anything here, keeping the baseline at 4.

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

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

The description 'Leave the current circle.' uses a specific verb (leave) and a specific resource ('the current circle'), and it stands in obvious contrast to sibling tools like join_circle and rename. The wording is clear and unambiguous, and 'current' adds useful contextual meaning. However, it doesn't explicitly distinguish itself from delete_circle_member, which could be confused as admin-based removal versus self-service leaving.

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 instead of alternatives like delete_circle_member or join_circle. An agent has no way to know the difference, when not to use this tool, or whether membership type matters.

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

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

With no annotations provided, the description must carry the behavioral transparency burden. 'List' implies a non-mutating read operation and 'all' implies an unfiltered scope, but the description does not disclose response size, pagination behavior, or permission implications.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every word contributes to conveying the core behavior.

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

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

For a simple list operation with an output schema and fully documented optional filters, the description is minimally workable. However, it does not mention the supported filter dimensions or distinguish this from the more specific chore-related sibling tools, leaving the agent to infer 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?

Schema description coverage is 100%, so all three parameters are already documented meaningfully in the input schema. The tool description adds no extra parameter-level semantics, but the schema carries the full explanatory weight.

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

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

The description uses a specific verb and resource ('List all chores from Donetick') and clearly states aggregate listing. It does not explicitly distinguish itself from sibling tools such as get_chore or get_all_chores_history, but the scope is reasonably clear.

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

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

There is no guidance about when to use list_chores over get_chore, get_chore_details, or the chore history tools. No prerequisites, exclusions, or alternative tool names are given, so usage context must be inferred entirely from the tool name and schema.

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

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

No annotations are provided, so the description must bear the full burden of behavioral disclosure. It only states 'List circles the user belongs to' with no mention of pagination, return format, authentication, ordering, or what qualifies as 'belongs to' (e.g., active vs. archived memberships). This leaves significant behavioral details undisclosed.

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

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

The description is a single, focused sentence with no redundant information or filler. It is front-loaded and concise.

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

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

Given the tool's low complexity (no parameters), an output schema that documents the return values, and a clear action/resource description, the description is sufficiently complete for an agent to understand and invoke the tool.

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

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

The input schema has zero parameters, so the description does not need to add parameter-level semantics. The baseline for no parameters is 4, and the description is consistent with that.

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 'List' with the resource 'circles' and scope 'the user belongs to', clearly distinguishing it from sibling list tools like list_chores or list_projects. It is unambiguous about what is being listed.

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

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

The description implies when to use the tool by naming the resource ('circles'), but it does not explicitly state when to use it over alternatives or provide exclusions. No alternative tool recommendations are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'List all projects,' implying a read operation but offering no details about output order, pagination, authentication, or side effects. For a minimal tool, this lacks transparency, though it does not contradict any 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 a single, succinct sentence 'List all projects.' that is fully focused and front-loaded. Every word contributes to the purpose, with 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?

Given the tool's simplicity (no parameters, simple list operation) and the presence of an output schema (indicated in context), the description is adequate. It does not explain return values, but that is covered by the output schema. The only gap is lack of behavioral context, but for a basic list operation, this is acceptable.

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, and schema description coverage is 100% (empty schema). No parameter details are needed, so the baseline of 4 applies. The description does not need to add parameter information 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 'List all projects' clearly specifies the verb 'list' and the resource 'projects', with the scope 'all' indicating a comprehensive retrieval. It distinguishes from sibling tools like create_project, update_project, and delete_project by being the only tool for listing projects.

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 clear context that this tool is used to retrieve all projects, but it does not explicitly mention when not to use it or alternatives. Since there are no alternative project-listing tools among siblings, the guidance is implicit but sufficient for a simple list operation.

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 itself must convey behavior. It says 'List all things', clearly indicating a read-only operation with no side effects, which is sufficient for a simple list tool. However, it does not mention any details like pagination, ordering, or output format, but those are likely in the documented output schema. It adds some transparency but not much beyond the obvious.

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

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

The description is a single, clear sentence with no redundancy. It states exactly what the tool does with no wasted 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 zero-parameter listing tool, the description is complete. It clearly states the purpose ('List all things') and adds a parenthetical clarification ('trackable values'), which fully explains the scope. With no annotations and no parameters, nothing more is needed.

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

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

The tool has zero parameters)Skip, so there is nothing to explain. The schema coverage is 100% (none), and the description directly matches the tool's behavior. No ambiguity.

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: 'List all things (trackable values).' It uses a specific verb ('list') with a clear resource ('things') and clarifies the scope ('all') and nature ('trackable values'), distinguishing it from sibling tools like 'get_thing' or 'list_chores'.

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

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

The description implies the use case (listing all things) but does not explicitly state when to choose this over alternatives. Sibling tools like get_thing or list_chores are not mentioned, though the distinct resource type makes it obvious. It provides clear context but no explicit exclusions or alternatives.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It only states 'Pause a running chore timer' without explaining what happens after pausing (e.g., resumability, state changes, side effects) or error conditions if the chore is not running. This is minimal behavioral disclosure.

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

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

The description is a single sentence with no wasted words. It is front-loaded and immediately conveys the core function.

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

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

Given the simplicity of the tool (one required parameter, no nested objects), the description provides enough to understand the basic operation. However, it lacks details about post-pause behavior, resumption options, or error handling, which could be important for effective use. The presence of an output schema may mitigate some of this, but the description alone is only minimally adequate.

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

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

The schema already fully describes the single parameter chore_id with 100% coverage. The description does not add any additional meaning or constraints beyond the schema, 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 ('Pause') and the target resource ('a running chore timer'). It effectively distinguishes this from sibling tools like start_chore, complete_chore, and skip_chore by specifying the timer-running 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?

The description implies the tool should be used when a chore timer is actively running, providing clear context. However, it does not explicitly mention alternatives or when not to use it, though the sibling names and the phrase 'running chore timer' imply the appropriate conditions.

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 disclosing behavioral traits. It only says 'redeem' without stating whether points are permanently deducted, whether a balance check occurs, what happens on failure, or whether any confirmation or side effects follow.

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

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

The description is a single sentence with no filler and the key action front-loaded. It is concise, though the brevity contributes to missing behavioral and usage context.

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

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

For a simple two-parameter mutation with an output schema and no annotations, the description covers the basic action and target adequately. However, it leaves out side effects, prerequisites, and failure behavior, making it 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 100%; both member_id and points already have clear descriptions in the JSON schema. The tool description adds no additional parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('redeem') with a clear object ('reward points') and recipient ('for a member'), making the basic action and scope understandable. It largely restates the title and does not distinguish from siblings, but no sibling tool appears to overlap with points redemption.

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, no prerequisites, and no exclusions. The only implied context is that it applies to a member's reward points, which is not enough to direct an agent's tool selection.

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 disclosing behavioral traits. It only says 'reject a pending chore completion' without explaining consequences, reversibility, permissions, or resulting state; this is minimal mutation disclosure.

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

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

The description is a single sentence with the verb front-loaded and no wasted content. The parenthetical adds a useful condition without bloating 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?

The tool is simple with one parameter and an output schema, reducing the need to describe return values. However, with no annotations and no mention of behavioral consequences, the description is not fully complete for an agent assessing safety and reversibility.

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

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

The schema fully documents chore_id at 100% coverage, so the description does not need to repeat parameter details. It adds no parameter-specific semantics beyond the pending-completion context, making 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?

The description uses a specific verb ('reject') and resource ('pending chore completion'), clearly distinguishing this tool from siblings like approve_chore and complete_chore. The parenthetical '(requires approval)' adds helpful scope.

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 clearly states this applies to pending chore completions, giving the agent a conditional context. It does not explicitly mention alternatives such as approve_chore, but the pending-completion qualifier is enough for this simple workflow.

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

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

With no annotations, the description carries the full burden. It only states what it does NOT do (mark complete) but doesn't disclose side effects, reversibility, or state changes beyond that. This is a significant gap 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?

One concise sentence that is front-loaded with the core purpose and a key distinction. No wasted 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?

While the tool is simple and has an output schema, the description lacks behavioral details and usage guidance. It's adequate for a basic action but could benefit from specifying consequences or prerequisites.

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 for the single parameter is 100% (chore_id). The description adds no additional parameter semantics, so the baseline 3 applies.

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

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

The description clearly states the action ('Skip a chore') and explicitly differentiates it from marking complete, which distinguishes it from the 'complete_chore' sibling tool.

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

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

The description implies when to use this tool (to pass over a chore without completing it) but does not explicitly mention alternatives like 'pause_chore' or provide 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?

With no annotations provided, the description carries the full responsibility for disclosing behavioral traits. It only states the action (start a timer, mark as in progress) without detailing side effects such as whether the timer automatically stops, what happens if the chore is already in progress, or whether it is reversible. No mention of permissions, rate limits, or return value format.

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 gets straight to the point. It is front-loaded with the key verb and object, with no superfluous words. Every part adds value.

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

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

The tool is simple with one parameter and an output schema, so the description need not explain return values. However, it lacks contextual details that would help an agent decide when to use it (e.g., state requirements, implications of starting a timer, interaction with pause/complete). A minimal but functional description, yet it could benefit from a brief note on typical usage or prerequisites.

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 covers 100% of the parameters (chore_id with description). The tool description adds no additional meaning beyond reaffirming the parameter is the chore ID. Baseline of 3 is appropriate since the schema already documents the parameter and the description does not provide extra context.

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

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

The description clearly states the verb 'start' and resource 'chore timer', with clarification that it marks the chore as in progress. It is differentiated from siblings like pause_chore and complete_chore by focusing on the initial start action, making its purpose 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 tool versus alternatives. No mention of prerequisites (e.g., chore must exist or be in a specific state) or exclusions (e.g., not for paused or completed chores). Sibling tools like pause_chore and complete_chore exist, but the description does not clarify when start is appropriate.

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

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

The description discloses the key behavioral transition from archived to active. Since no annotations are provided, it carries the transparency burden, but it omits details like idempotency, permissions, or what happens if the chore is already active. This is minimal but not misleading.

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 a useful parenthetical clarification. Every word earns its place, 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 one-parameter state-transition tool, the description plus schema is sufficient for an agent to select and invoke the tool correctly. The presence of an output schema removes the need to describe return values, and the archived-to-active transition is clearly implied.

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 single parameter chore_id is already clearly documented in the schema. The description itself adds no additional parameter-level semantics, 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 uses a specific verb ('Unarchive') with a clear resource ('a chore') and adds the clarifying state transition '(back to active)'. This cleanly distinguishes it from related tools like archive_chore, pause_chore, or delete_chore.

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 '(back to active)' implies the intended use case: reactivating an archived chore. However, the description does not explicitly state when to use this tool over alternatives, nor does it mention exclusions such as not applying to paused or deleted chores.

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 full responsibility for behavioral disclosure. It does not explain side effects (e.g., whether points are revoked, if the completion record is deleted), permissions required, or behavior when there is no prior completion. This is a significant gap for a mutation-like undo operation.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the essential 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 one-parameter tool, the description provides the minimum viable information. However, it lacks behavioral context around side effects, failure cases, and user scoping. The presence of an output schema somewhat reduces the need to describe return values, but the operation's semantics are still 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?

The input schema fully describes chore_id as 'The ID of the chore' (100% coverage). The description adds no extra semantic meaning beyond this, 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 'Undo the last completion of a chore' clearly states the specific action (undo) and target (last completion of a chore). It distinguishes from siblings like complete_chore and skip_chore. Minor ambiguity exists about the scope of 'last' (per user, per chore, globally), but the overall purpose is clear.

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 tool is used to reverse a previous completion, but it does not explicitly state when to use it, when not to, or name alternative tools. Guidance is minimal, relying on the verb 'undo' to convey intent.

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

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

With no annotations, the description carries the full burden. It does disclose that this is a mutation operation (implicit in 'update') and adds the partial-update behavior. However, it does not reveal other behavioral aspects like permission requirements, potential side effects, or how null values are treated (though the schema allows nulls). This is minimal but marginally adequate.

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: two sentences with zero waste. The first sentence states the purpose, and the second provides the key usage guideline. It is front-loaded and 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?

The tool involves 18 parameters and has an output schema, but the description is quite thin. It provides the essential partial-update rule, which is critical, but it lacks guidance on edge cases, relationships between fields, or how this tool relates to specialized update tools. Given the high schema coverage, the description is adequate but not comprehensive.

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 each parameter is documented in the schema. The description adds a general meta-instruction about partial updates, which is useful for all parameters collectively, but it does not add per-parameter meaning beyond what the schema provides. Baseline 3 is appropriate, and the meta-instruction doesn't elevate it 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 clearly states the action ('Update an existing chore') and the resource (chore), and the phrase 'with new values' implies a general update. However, it does not distinguish this tool from specialized siblings like update_chore_priority or update_chore_assignee, so it's not fully discriminative.

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 second sentence gives a clear usage rule: 'Only provide fields you want to change - other fields remain unchanged.' This is helpful but does not mention when to use this tool versus the more targeted update tools (e.g., update_chore_priority). No exclusions or alternatives 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 must fully disclose behavior. It only states the action ('Reassign') which implies mutation, but it does not mention side effects, prerequisites, permissions, validation, or what happens to the previous assignee. With no annotations to cover the safety profile, this is a significant gap for a mutating 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?

The description is a single, front-loaded sentence with zero redundancy. It conveys the core purpose efficiently, and every word contributes meaning. This is an example of ideal conciseness for a simple tool.

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

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

The description is short but covers the basic purpose. However, with no annotations and no guidance on when to use vs. alternatives, it is not fully complete. The presence of an output schema helps, but the absence of behavioral details and usage recommendations leaves the agent to infer crucial context. For a two-parameter tool with no annotations, this is minimally acceptable but has clear gaps.

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

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

Schema coverage is 100%—both parameters have descriptions in the schema. The tool description adds no extra meaning beyond what the schema already provides. Per the rubric, a baseline of 3 is appropriate when the schema does the heavy lifting, and the description does not enhance parameter understanding.

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 ('Reassign') and resource ('a chore') with a precise aspect ('to a different circle member'), clearly distinguishing it from sibling tools like update_chore, which handles other fields, and other chore-specific tools. It is unambiguous about the tool's single responsibility.

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 tool is used when the assignee needs to be changed, but it does not explicitly contrast it with alternatives like update_chore or state any exclusions (e.g., 'Use this only for changing assignee; for other updates, use update_chore'). Without such guidance, an agent may not know when to choose this tool over similar ones.

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, and the description does not disclose side effects, permissions, validation behavior, or return details. It only states the action without explaining consequences or requirements, which is a significant gap 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?

The description is a single, front-loaded sentence that directly states the tool's purpose. There is no filler, redundancy, or unnecessary detail.

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, parameters are fully documented in the schema, and an output schema exists, so the description is mostly adequate. However, the lack of annotations and any behavioral or usage context leaves some important information to be inferred by the agent.

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

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

The input schema fully describes both parameters, including the meaning of priority values (0=unset, 1=lowest, 4=highest). The description adds no extra semantic value beyond the schema, so the baseline score 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 uses a specific verb ('Update') and clearly identifies both the target resource (a chore) and the specific field (priority level). This distinguishes it from sibling tools like update_chore or update_chore_assignee.

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

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

The intended use is implied by the tool name and description but there is no explicit guidance on when to use it versus alternatives. No exclusions or comparisons to sibling tools 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 were provided, so the description carries the full burden of explaining behavioral traits. It merely restates the update operation without disclosing whether it's a partial or full update, whether omitted fields are preserved, or side effects. It also fails to mention that 'name' is required even when updating other fields, which is a meaningful gap.

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

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

The description is a single, efficient sentence that conveys exactly what the tool does. There is zero redundancy or filler.

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

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

Given the output schema exists and the parameter schema covers all fields, the description is nearly complete for a straightforward CRUD update. However, it could have mentioned the required 'name' parameter for update operations, which would have made it fully self-contained.

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 each parameter has a clear description in the schema itself. The description only lists the field names without adding extra syntax or format details. The baseline of 3 applies since the description doesn't compensate 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?

Uses the specific verb 'Update' plus the resource 'project' and explicitly enumerates the mutable fields (name, description, color, icon), making the purpose immediately obvious. It distinguishes itself from sibling tools by its resource-specific scope (project) and action, even though other project tools like create_project exist.

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 makes it clear this tool updates an existing project, but it does not state when to use it versus alternatives (e.g., when to use update_project over create_project) or mention any preconditions. Usage is implied from the verb 'Update' and the tool name, but no explicit context or exclusions 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 are provided, so the description carries the full burden. It states the action but doesn't disclose any behavioral traits such as whether it's reversible, if it affects parent chore status, or any side effects. For a mutation tool, this is a significant gap.

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

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

The description is a single, concise sentence that front-loads the purpose. No wasted words, and it's appropriately sized for a simple 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?

Given the tool's simplicity, the description is mostly complete. However, with no annotations and an output schema present, the description doesn't explain what the response contains or any side effects. For a mutation tool, it could benefit from noting whether the update is idempotent or if it triggers any downstream effects.

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 three parameters clearly. The description adds minimal value beyond the schema, but it does clarify the boolean semantics ('True to mark complete, False to mark incomplete') which is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action ('Mark a subtask as complete or incomplete') and the resource ('within a chore'), which is specific and distinguishes it from sibling tools like complete_chore or update_chore. However, it doesn't explicitly differentiate from other subtask-related tools, but given the sibling list, it's clear enough.

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

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

The description implies when to use it (when updating subtask completion status) but doesn't provide explicit guidance on when not to use it or alternatives. It's adequate but lacks explicit exclusions or comparisons to similar tools like complete_chore.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It mentions 'update' but does not specify whether it performs a full replace, whether missing fields are left unchanged (though name and type are required), whether permissions are needed, or what happens if the thing does not exist. The description adds minimal behavioral context beyond the schema.

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 directly states the tool's purpose. It is front-loaded with the key action and objects, and contains no unnecessary words or filler.

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

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

For a mutation tool with no annotations and only a minimal description, the context is incomplete. The description does not mention the existence of an output schema (though that is structured data), nor does it address potential side effects, idempotency, or error conditions. It is barely adequate for a simple tool but lacks the richness expected for a state-changing 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 100% since every parameter has a description in the schema. The description lists the fields (name, type, state) but does not add any additional semantics beyond what the schema already provides. It meets the baseline for full schema coverage without adding extra value.

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

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

The description clearly states the action (update), the resource (thing), and the specific fields affected (name, type, optional state). This distinguishes it from sibling tools like change_thing_state (which only changes state) and create_thing (which creates a new thing).

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention that this is the appropriate tool for updating name/type, nor does it exclude cases where only state changes (which could use change_thing_state). The usage context is entirely implied.

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