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

Annotations are absent, so the description must disclose behavioral traits on its own. It only states the action without revealing side effects (e.g., whether adding an existing customer overwrites or fails), permission requirements, or idempotency. This is insufficient for a mutation 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, direct sentence with no filler or redundant information. It is appropriately sized and front-loads the essential action, making it efficient for an agent to parse.

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?

Without annotations or an output schema, the description is the sole source of context. It lacks information about return values, side effects, error conditions, and when to use alternatives. For a mutation tool, this is a significant gap that could lead to incorrect usage.

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 describes all three parameters (id, customer_type, customer_id) with 100% coverage. The description adds no additional meaning beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Add') and resource ('customer to a project'), with the clarification that the customer can be a contact or company. It clearly distinguishes from related siblings like teamleader_remove_project_customer and teamleader_add_project_owner.

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 teamleader_add_project_owner or teamleader_link_contact_to_company. It does not mention prerequisites (e.g., the project must exist, customer must exist) or scenarios where this tool is not 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?

No annotations are provided, so the description carries the full burden. It states the operation is a link (a mutation), but doesn't disclose whether it's idempotent, whether it overwrites existing links, what happens if the deal is already linked, or any side effects. For a mutation tool with zero annotation coverage, 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?

A single sentence with no waste. The action and both resources are front-loaded. It is appropriately sized for a simple linking operation.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It doesn't mention return behavior, error conditions, or idempotency. The simple parameter set and clear action keep it from being a 1, but an agent would need more context to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('The project ID' and 'The deal ID to link'). The description adds no extra meaning beyond the schema, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description 'Link a deal to a project' clearly states the action (link) and the two resources involved (deal, project). It is specific enough to distinguish from sibling tools like teamleader_remove_project_deal, though it doesn't explicitly name that sibling.

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

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

No guidance on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., project must exist, deal must exist) or when linking is appropriate. The sibling list includes teamleader_remove_project_deal, but the description doesn't contrast with it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Add', which implies a mutation, but does not mention permissions, idempotency, failure behavior, or whether adding an owner replaces existing owners.

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

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

The description is a single efficient sentence with no filler or repetition. It is appropriately front-loaded, though it is quite terse and could include more operational context without becoming 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?

For a simple two-parameter mutation with fully documented schema properties, the description is minimally adequate. However, with no annotations and no output schema, it lacks behavioral context and usage guidance that would make it fully complete for an agent deciding whether and how to invoke it.

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

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

Schema description coverage is 100% and both parameters have clear descriptions ('The project ID' and 'The user ID to add as owner'). The tool description adds no semantic detail beyond the schema, which aligns with the baseline 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 states a clear action ('Add') and resource ('a user as an owner of a project'), so an agent can understand the core operation. It does not explicitly differentiate from siblings like teamleader_assign_project or teamleader_remove_project_owner, though 'owner' provides some distinction.

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

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

The description gives no guidance about when to use this tool versus alternatives such as teamleader_assign_project or teamleader_remove_project_owner. There are no context cues, exclusions, or prerequisites provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action without explaining effects (e.g., whether it overwrites existing links, fails if quotation already linked, or requires specific permissions). No extra context about the operation's consequences is provided.

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

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

The description is a single, concise sentence with no unnecessary words. It front-loads the core action and is appropriately short for a simple link operation, though it could arguably include a bit more context without sacrificing conciseness.

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

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

For a simple operation, the description is minimal but lacks important contextual details such as idempotency, return behavior, and prerequisites (e.g., quotation must exist). Given no annotations and no output schema, the description is insufficient for an agent to fully understand the tool's behavior and side 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%, with both 'id' and 'quotation_id' adequately described in the schema. The description adds no additional parameter context beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description states a clear verb ('Link') and resource ('a quotation to a project'), which is immediately understandable. It distinguishes itself from the sibling tool teamleader_remove_project_quotation by implying the opposite action, though it doesn't explicitly name it.

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

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

No guidance is provided on when to use this tool versus alternatives or any prerequisites. There is no mention of when linking is appropriate (e.g., before project closure) or any exclusions. The agent must infer its usage solely from the name and description.

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

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

With no annotations, the description carries the behavioral burden. It discloses a valuable non-obvious behavior: midnight-spanning entries are split automatically. However, it does not disclose response behavior, permission requirements, or side effects beyond the obvious insertion, which keeps this at mid-range.

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

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

Two sentences, front-loaded with the operation, then key constraints, and a valuable edge-case note. 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?

All required input semantics are effectively covered by the schema plus description, and the midnight split note is a good addition. However, with no output schema and no annotations, the description gives no indication of what a successful call returns or what failures/authorizations to expect, so an agent is still partly in the dark.

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%, so baseline is 3. The description adds value by stating the one-of duration_minutes/duration_seconds constraint and tying it to started_at, a requirement the JSON schema leaves optional, and it maps subject types to real-world entities.

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 ('Log time worked') against a defined resource ('time tracking') and clarifies the kinds of subjects it applies to. This is clearly distinct from sibling time-tracking verbs (list/get/update/delete).

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

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

It gives clear invocation context: provide duration and started_at when logging against a subject. It stops short of explicitly naming alternatives or when not to use it, so it misses the top anchor.

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 full responsibility for behavioral disclosure. It only states the basic action without mentioning side effects, permission requirements, or whether the assignment overwrites existing ones, 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?

A single sentence with no redundancy; the core purpose is front-loaded and immediately clear. 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?

The description is minimal and does not explain the broader context of assignment, such as how it differs from adding an owner or customer, or what the response indicates. For a mutation with no annotations and no output schema, more context is needed for correct use.

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

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

All three parameters are already described in the schema, and the description adds no additional semantic detail about how they interact or any constraints beyond the enum. Baseline of 3 applies given 100% 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 action (assign), the object (a user or team), and the target (a project). This distinguishes it from unassign and other project-related tools like add owner, making the 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?

The description offers no guidance on when to use this tool versus alternatives such as teamleader_add_project_owner or teamleader_unassign_project. There are no conditions, prerequisites, or exclusions mentioned, leaving the agent to infer selection criteria from the tool name alone.

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

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

Annotations already provide destructiveHint=true, signaling the destructive nature. The description adds the 'for all attendees' scope, which implies broad impact (e.g., all attendees are affected), but it does not disclose irreversibility, notifications, or permission requirements. It adds some context beyond the annotation but not a full behavioral picture.

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 filler. Every word adds value, stating the action, the resource, and the scope.

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

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

For a simple one-parameter tool with a destructiveHint annotation, the description provides the core action and scope. It does not explain return values or side effects, but these are not essential for invocation. It could mention irreversibility, but the annotation and purpose cover the main concerns.

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 100% description coverage for the single 'id' parameter ('The event ID to cancel'). The description adds no additional meaning to the parameter, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Cancel') and resource ('calendar event'), and adds a clear scope ('for all attendees') that differentiates it from siblings like teamleader_update_event or teamleader_create_event. An agent can immediately tell what this tool does.

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

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

The description implies usage when an event needs to be cancelled, but it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or prerequisites. There is no competing cancel sibling, so ambiguity is low, but explicit guidance is missing.

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 behavior. It only states the state change ('close'), but does not disclose what happens to underlying tasks or materials (despite the closing_strategy parameter hinting at this), whether it is reversible, or if special permissions are required. 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, front-loaded sentence with zero filler. It earns its place by clearly stating the core action. There is no unnecessary verbosity, and the structure is optimal for the minimal information provided.

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 only two parameters but no annotations and no output schema, the description is insufficiently complete. It does not explain the semantic difference between closing and deleting, nor the effects of the closing_strategy parameter on underlying tasks and materials. An agent cannot fully judge the impact of invoking this tool from the description alone.

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

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

Schema description coverage is 100%, with both 'id' and 'closing_strategy' already described adequately. The description adds no extra parameter meaning, but the schema already documents each parameter's purpose and the default behavior. Baseline 3 applies because the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Mark a project as closed.' This clearly distinguishes the action from siblings like teamleader_reopen_project, teamleader_delete_project, and teamleader_update_project. The purpose is immediately unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of when closing is appropriate instead of deleting, updating, or reopening, and no indication of prerequisites or consequences that would help an agent select it correctly.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Mark a task as complete' signals a state mutation but does not mention reversibility, side effects, prerequisites, or what happens after completion, leaving the agent without meaningful 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?

The description is a single front-loaded sentence with no filler or repetition. It is appropriately sized for a simple one-parameter operation and every word earns its place.

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

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

For a simple one-parameter mutation with full schema coverage, the description states the essential operation. However, with no annotations and no output schema, it leaves out related behavioral context such as reversibility via teamleader_reopen_task, so it is adequate but minimal.

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 fully documents the single id parameter. The description adds only the contextual phrase 'to complete' and provides no additional format, constraints, or behavior beyond the schema.

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

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

The description uses a specific verb, 'Mark', and a resource, 'task', with a clear resulting state, 'complete'. It is clear about the operation but does not explicitly distinguish itself from the generic sibling teamleader_update_task, which could also alter task status.

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

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

No guidance is given about when to use this tool instead of teamleader_update_task, or how it relates to teamleader_reopen_task. There is an implied use case—completing a task—but no alternatives, exclusions, or preconditions are described.

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

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

Annotations are completely absent, so the description must carry the full burden of behavioral disclosure. 'Create' implies a mutation, but there is no mention of side effects, required permissions, idempotency, error behavior, or what happens to existing data. The description provides no transparency beyond the bare action.

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

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

The description is extremely concise at a single sentence, which is appropriately sized for a simple create operation. It is front-loaded with the core action and resource. However, it lacks any structural elements like lists or sections, though that is not necessary for such a short description.

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 7 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the result of creation, any required context like authentication, or what happens on success or failure. An agent calling this tool would have no idea what to expect after invocation, making it inadequate for a mutation with multiple inputs.

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

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

Schema description coverage is 100%, so all 7 parameters are documented in the input schema with descriptions like 'Company name', 'Tags to assign', etc. The tool description adds no extra parameter semantics, but since the schema fully covers them, 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 verb 'create' and resource 'company' in 'Teamleader Focus', which is unambiguous. It distinguishes from sibling create tools like create_contact or create_project by naming the specific resource. However, it lacks additional differentiation or context about the scope of a company object, so it falls short of a perfect 5.

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

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

There is no guidance on when to use this tool versus alternatives such as teamleader_create_contact or teamleader_create_project. No mention of prerequisites, exclusions, or conditions that would make this the right choice. The description is purely declarative with no usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it creates a contact, which is a mutation, but it does not disclose potential side effects, permission requirements, duplicate handling, or what happens on failure. The agent is left unaware of any operational nuances, making this a significant gap for a create 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 sentence with no fluff, which is efficient, but it is under-specified for a tool with 8 parameters. It is not front-loaded with important usage details; it only restates the obvious purpose. While it is concise, it does not earn its place by adding value beyond the tool's name.

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

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

Given the tool has 8 parameters and no output schema or annotations, the description is far too thin. It does not mention required fields, typical usage scenarios, or any integration context. Although the schema covers parameter definitions, the description fails to provide the broader context an agent needs to decide when and how to invoke this tool correctly, making it incomplete 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%, meaning the input schema already documents every parameter with meaningful descriptions (e.g., 'Primary email address', 'Language code'). The description adds no parameter-level information whatsoever, so it does not exceed the baseline of 3. It neither clarifies nor contradicts the schema, but it also does not compensate for any potential 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 a specific verb ('Create'), a resource ('a new contact'), and the system ('Teamleader Focus'). This clearly distinguishes it from sibling tools like update_contact, delete_contact, and get_contact. It is concise and unambiguous, though it does not elaborate on the fields or any special conditions, so it stops short of a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as whether a company must exist first, nor does it contrast with update_contact or link_contact_to_company. The only implicit signal is that this is for creating a new contact, which is not enough to route an agent correctly in ambiguous situations.

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, but it only says 'create' and adds no detail about side effects, required fields, validation, or response. The mutation is implied but not elaborated.

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

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

Single sentence, no filler, and the action and resource are front-loaded.

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

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

For a mutation tool with no annotations or output schema and 9 parameters (4 required), the description should provide more behavioral and usage context; it currently leaves the agent to infer everything from the schema.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters; the description adds no parameter-level meaning, which is acceptable at baseline.

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

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

Description names a specific action ('Create') and resource ('calendar event in Teamleader Focus'), clearly distinguishing it from sibling update/cancel/list/get event tools.

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

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

No guidance on when to choose this over teamleader_update_event or teamleader_cancel_event, nor any prerequisites. The only implied context is creating a new event.

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 states that the operation adds a note and can optionally notify users, but it does not mention permissions, reversibility, return values, or what happens on invalid subject types. This is a significant gap for a create 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 words. The trailing 'etc.' is slightly vague, but overall the structure is efficient and easy to parse.

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

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

For a mutation tool with no annotations and no output schema, the description is thin. It does not describe the response, error conditions, or side effects beyond optional notifications, and the agent must rely entirely on the schema to understand required inputs. The complete parameter coverage helps, but the behavioral context is missing.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters. The description adds little beyond restating the optional notification behavior and listing subject types already present in the enum, so it meets the baseline but does not elevate it.

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

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

The description uses a specific verb ('Add') and resource ('a note to a subject'), and enumerates common subject types, making the tool's purpose immediately clear. It does not explicitly compare itself to sibling tools like teamleader_update_note or teamleader_list_notes, so it misses the top score for sibling differentiation.

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

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

The description implies when to use the tool: whenever a note needs to be created on a supported entity. However, it offers no explicit guidance about alternatives (e.g., updating an existing note with teamleader_update_note) or when not to use it, leaving the routing decision mostly to inference.

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

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

With no annotations, the description carries the behavioral burden. It discloses a non-obvious side effect ('The creating user is automatically added as an owner') and notes that all fields except title are optional. However, it does not mention permissions, idempotency, or what the response contains.

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

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

Three sentences with no filler, front-loading the action and resource. Each sentence adds useful information: purpose, required/optional fields, scheduling, and a side effect.

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 23-parameter tool with no output schema, the description covers the core creation context and side effects, but it omits what the tool returns (e.g., created project ID) and any permission requirements. The schema covers parameter semantics, so the main gap is response 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?

Schema description coverage is 100%, so the baseline is 3. The description's parameter hints ('Only title is required', 'Set start_date/end_date to schedule') largely restate schema information, and the owner side effect is already present in the owner_ids schema description. It adds minimal value beyond the schema.

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

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

The description opens with 'Create a new project in Teamleader Focus (next-gen projects module)', specifying a clear verb and resource. It distinguishes itself from sibling project tools (update, delete, list, get) by being the create operation, and the module qualifier adds specificity.

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

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

The description clearly implies use when creating a new project, and it provides parameter usage guidance ('Only title is required', 'Set start_date/end_date to schedule'). It does not explicitly name alternatives or exclusions, but the create verb makes the context unambiguous.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the operation implied by the tool name. It does not mention required fields, object relationships, side effects, or what the response contains, so it adds no 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 front-loaded sentence with no filler or redundant elaboration. It earns its place, though the brevity comes at the cost of 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 10-parameter creation tool with no output schema and no annotations, a single generic sentence is inadequate. It does not explain how the optional IDs relate, what Teamleader requires beyond title and due_on, or what constraints apply, leaving the agent to rely entirely on the schema.

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

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

The input schema describes all 10 parameters with 100% coverage, so the schema carries the parameter-semantics load. The description itself adds nothing about parameters, which is acceptable at the baseline because the schema descriptions are sufficient.

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

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

The description names a specific verb and object: create a new task in Teamleader Focus. This is clear enough to distinguish it from sibling tools like teamleader_create_note or teamleader_create_company, even though it does not elaborate on scope or edge cases.

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

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

No guidance is given about when to create versus update or schedule a task. The existence of siblings like teamleader_update_task, teamleader_complete_task, and teamleader_schedule_task is not acknowledged, so the agent must infer the tool's appropriate use from its name alone.

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

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

The destructiveHint=true annotation already flags the operation as destructive, but the description adds meaningful context with 'This is irreversible,' informing the agent that the deletion cannot be undone. This goes beyond the generic annotation and is a critical behavioral fact for invocation decisions.

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 exactly two short sentences with no filler. The core action is front-loaded, and the essential caveat (irreversibility) follows immediately, ensuring every word contributes 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?

For a single-parameter delete operation, the description conveys the action and the most important consequence. It does not mention potential restrictions (e.g., whether a company with linked records can be deleted), but given the simple profile, the destructive annotation, and the absence of an output schema, the essentials are adequately covered.

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 documents the only parameter ('The company ID to delete') with 100% schema description coverage, so the description does not need to add parameter details. The tool description offers no additional parameter semantics, which is appropriate given the schema's completeness.

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') plus a resource ('a company') and platform ('Teamleader Focus'), making the operation unambiguous. The additional warning 'This is irreversible' reinforces the purpose and distinguishes it from non-destructive company tools like create, update, get, and list.

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 implies when to use the tool—whenever a company must be deleted—and the resource name distinguishes it from sibling delete operations on other entities. However, it gives no explicit when-not-to-use guidance or caveats about alternatives, such as whether soft-delete or archiving should be preferred in certain situations.

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 destructiveHint annotation already signals destruction, and the description goes further by adding 'This is irreversible,' which is a valuable behavioral detail. It does not mention potential side effects like cascading deletions or whether certain linked records block deletion, but for a simple delete operation it discloses the most critical behavioral trait.

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

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

The description is two sentences with no wasted words. The core action appears first, and the irreversibility warning is separated concisely. Every word contributes to understanding the tool's purpose and risk.

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

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

For a single-parameter, destructive operation with a fully documented schema, the description is nearly complete. It covers the action, target, and irreversibility. It falls slightly short by omitting any mention of return behavior, prerequisites, or effects on linked records, which would be useful in the absence of an output schema.

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

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

Schema description coverage is 100%, and the 'id' parameter is already described as 'The contact ID to delete.' The description adds no additional parameter-level context, so it appropriately relies on the schema rather than duplicating information.

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

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

The description clearly states the specific verb ('Delete') and resource ('contact from Teamleader Focus'), leaving no ambiguity about what the tool does. It distinguishes itself from sibling contact tools like teamleader_create_contact, teamleader_update_contact, and teamleader_get_contact via the delete action.

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

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

The description implies when to use the tool: when a contact needs to be removed from Teamleader Focus. However, it provides no explicit guidance about when not to use it, prerequisites, or alternatives. The irreversibility warning suggests caution but does not fully articulate usage context beyond the basic action.

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

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

The description adds irreversibility, which goes beyond the destructiveHint annotation, and explains that the delete strategy controls the fate of linked tasks and time trackings. This gives meaningful behavioral context beyond what the annotation alone conveys.

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

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

Two sentences with no wasted words. The core action and key requirement are front-loaded, and the description is easy to parse quickly.

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

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

With only 2 fully described parameters, a destructiveHint annotation, and no output schema, the description covers the essential extra context: irreversibility and the need for a delete strategy. Nothing an agent needs to call the tool correctly is missing.

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

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

Schema coverage is 100%, so the schema fully documents both parameters. The description mentions the delete strategy's purpose but does not add detail beyond the schema's enum descriptions, so it provides minimal additional 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 (Delete) and resource (project), making it unambiguous and distinct from sibling delete tools for other resources. However, it does not explicitly name a sibling or differentiate itself, so it falls short of a 5.

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

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

No guidance is provided on when to use this tool vs alternatives. It does not mention conditions, exclusions, or alternative operations like closing or archiving a project. The only context is the delete strategy parameter, which is operational, not selective.

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

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

The annotation destructiveHint=true already signals destructiveness. The description adds the 'irreversible' warning, which reinforces the behavioral profile but does not disclose additional side effects, permissions, or cascading consequences.

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

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

The description is two short sentences with no filler. The core action is stated first, and the irreversible warning is a meaningful addition that 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 single-parameter delete operation with a destructiveHint annotation, the description is nearly complete. It could mention potential side effects on related data, but the essential context for calling the tool correctly is present.

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 the only parameter 'id' with a clear description. The tool description adds no extra semantic meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Delete') and resource ('a task'), making the tool's purpose unambiguous. It is clearly distinct from sibling tools like teamleader_update_task, teamleader_complete_task, and teamleader_schedule_task.

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

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

The description implies usage: use this when a task needs to be deleted. However, it does not explicitly contrast with alternatives or state when not to use it, leaving some guidance to inference.

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

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

The annotation destructiveHint=true already signals a destructive operation, and the description adds the important behavioral detail that the deletion is irreversible. This goes beyond the annotation and sets correct expectations without over-explaining.

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

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

Two short sentences, zero filler. The core action is front-loaded, and the irreversibility warning 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?

This is a single-parameter destructive operation with aligned annotations. The description plus schema fully equips an agent to invoke it correctly; no return format or additional context is essential here.

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

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

Schema description coverage is 100%, and the single required parameter 'id' is already clearly described as 'The time tracking entry ID to delete'. The description adds no new parameter meaning, so the baseline score of 3 applies.

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

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

The description names a specific action ('Delete') and a specific resource ('a time-tracking entry'), which clearly distinguishes this tool from sibling delete tools and from the add/update/list time-tracking tools. The purpose is unambiguous.

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

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

There is no guidance on when to use this tool as opposed to alternatives like teamleader_update_time_tracking or teamleader_add_time_tracking. The situation is implied by the delete verb, but no explicit context, exclusions, or alternatives 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 of behavioral disclosure. It only states the basic duplication action and does not disclose whether tasks, custom fields, customer links, or other project data are copied, whether the source project is modified, or what the return value is. This is a meaningful 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 well-structured sentence, front-loads the action, and contains every word necessary to convey the core operation without 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 two-parameter tool, the description supplies enough to invoke it, but no output schema exists and the description does not explain what the call returns or what project data is carried over. An agent can call the tool correctly but would be uncertain about the result and side 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% and both id and title have clear schema descriptions. The tool description only echoes the title concept ('with the given title') without adding extra format or constraint details, so the schema already carries the semantic 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: 'Duplicate an existing project into a new project with the given title.' It clearly distinguishes this from siblings like create_project or update_project by naming the duplication operation and the destination new project.

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 context is implied: an agent can infer this tool is for copying an existing project when a title is supplied. However, it does not explicitly state when to choose it over create_project, nor does it give any exclusionary guidance or prerequisites.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but the description does not disclose response format, error behavior, permissions, or what 'detailed information' includes. This is a meaningful gap for a tool with no annotation safety profile.

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. The core action and resource are front-loaded, making it easy to parse quickly.

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 getter with no output schema, the description is adequate but minimal. It does not specify return fields or behavior when the company is not found, though the operation is straightforward enough for an agent to invoke correctly.

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

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

Schema coverage is 100% and the single 'id' parameter is documented as 'The company ID'. The description adds no additional parameter meaning, 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?

Description uses a specific verb 'Get' and resource 'specific company', clearly distinguishing it from list/create/update/delete company siblings. However, it does not explicitly differentiate from other getters like teamleader_get_contact or mention that it retrieves by ID, so it stops short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives such as teamleader_list_companies or teamleader_get_contact. The description implies use when you have a company ID and need details, but no explicit context or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but the description doesn't disclose the return format, what 'detailed information' encompasses, or error behavior. For a tool with zero annotation coverage, this is a notable 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?

A single, front-loaded sentence with no wasted words. It communicates the core purpose efficiently, though the brevity comes at the cost of behavioral and usage 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?

For a simple fetch-by-ID tool with one parameter, the description is mostly adequate, but with no output schema it should hint at the return shape. It leaves the agent without any expectation of what 'detailed information' actually contains, which is a meaningful completeness gap.

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

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

Schema description coverage is 100% and the id parameter is already described as 'The contact ID' in the schema. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a clear verb ('get') and resource ('a specific contact'), which is easily distinguishable from the sibling list_contacts tool. However, it doesn't explicitly name the sibling it is not, so differentiation relies on the tool name pattern rather than description.

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

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

No explicit when-to-use or alternative guidance is given. Usage is only implied — an agent can infer it should be called when it has a specific contact ID, but the description never states this or contrasts with list_contacts for bulk retrieval.

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

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

No annotations are provided, so the description carries the full burden. It discloses the read-only nature ('Get'), the authentication prerequisite ('currently authenticated'), and the returned information fields. However, it does not mention error behavior, what happens without a valid auth context, or any side effects — adequate for a simple getter 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?

One compact sentence that front-loads the verb and resource, followed by a parenthetical that adds the practical use. 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 no-parameter tool with no output schema, the description covers purpose, prerequisites, and the main fields returned. It omits edge-case handling (e.g., unauthenticated calls), but the explicit 'currently authenticated' wording hints at the required context, making this minimally complete for such a 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?

The tool has zero parameters and 100% schema coverage, so the baseline is 4. The description reinforces that no input is required and clarifies what the tool returns instead, which fully compensates for the absence of parameter documentation.

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

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

The description uses a specific verb ('Get') and a clear resource ('currently authenticated Teamleader user'), and the parenthetical explicitly names the returned data. This distinguishes it from sibling getters like teamleader_get_contact (fetches by ID) and teamleader_list_users (lists all users), so an agent can select it correctly even among many siblings.

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

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

The description states the useful scenario ('to find your own user ID, account, language and timezone'), which communicates when to call it. It doesn't explicitly name alternatives, but the tool's unique 'current authenticated user' scope makes the appropriate use case unambiguous; no exclusions are needed.

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

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

With no annotations provided, the description carries the behavioral burden. 'Get' clearly implies a read-only operation with no side effects, but the description does not disclose error behavior, return format, or what 'detailed information' includes.

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

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

The description is a single concise sentence with no filler or redundancy. It states the action and resource directly, earning its place without 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?

For a simple one-parameter get tool, the description is minimally adequate: an agent knows to supply an event ID and expect detailed information. However, with no output schema, the vague 'detailed information' leaves the return shape unspecified, and no mention is made of not-found or error 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 schema already describes the only parameter ('The event ID') with 100% coverage. The description adds no additional semantic meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the action ('Get') and the resource ('event'), and the word 'specific' distinguishes it from list_events. It does not explicitly differentiate itself from sibling tools, but the purpose is unambiguous.

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

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

The description implies it should be used when a specific event ID is known and detailed information is needed, but it does not explicitly state when to use this tool versus list_events or mention any exclusions or alternatives.

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

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

No annotations are provided, so the description must carry behavioral disclosure. The verb 'Get' implies a read-only operation, which is useful, but it does not explicitly state side-effect-free behavior, permissions, or error behavior. Minimal disclosure for a simple get 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?

Single sentence with no waste. Front-loaded with the core action and resource, and the 'including...' clause adds useful return-field context without bloat.

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

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

With no output schema and no annotations, the description only partially characterizes the return value by naming three fields and saying 'details.' It does not cover all possible fields, error conditions, or auth requirements, but for a 1-parameter get tool, the essential call contract is present.

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

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

Schema coverage is 100% and the single id parameter is fully described in the schema ('The product ID'). The description adds no parameter-specific semantics, so baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('single product'), and differentiates from sibling teamleader_list_products by explicitly scoping to a single product. Mentioning selling price, tax rate, and category adds specificity beyond the name.

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

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

Implies use when a single product ID is available and details are needed, but does not explicitly name alternatives like teamleader_list_products or state when not to use. No exclusions or comparison to 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 full burden of behavioral disclosure. It only restates the read-only intent without mentioning response shape, permissions, error behavior, or any 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 no filler. It is concise and easy to parse, though 'detailed information' adds slight vagueness without extra 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?

This is a simple one-parameter getter, so the description is minimally adequate. However, with no output schema and no annotations, it does not clarify what fields of 'detailed information' are returned or whether any special conditions apply.

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 only parameter 'id' is fully described in the schema as 'The project ID', giving 100% schema coverage. The description adds no additional parameter meaning beyond calling it a specific project.

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 ('Get') and resource ('specific project'), distinguishing it from project listing, creation, and update tools. 'Detailed information' is somewhat vague, but the core purpose is unambiguous.

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

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

It implies use when you have a specific project ID and need details, but it does not explicitly mention alternatives such as teamleader_list_projects for discovering projects or how this relates to other project-related getters.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that detailed information is returned, but it does not describe what fields the 'detailed information' contains, whether the response includes nested objects, or how errors are handled. For a read tool, some indication of return shape would add value beyond the one-line purpose.

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. Every word contributes to conveying the operation clearly and 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 get-by-id tool with one well-documented parameter, the description is mostly complete: it identifies the resource, the operation, and the required identifier. The lack of an output schema means a bit more detail about the returned 'detailed information' would improve completeness, but the core invocation path is fully covered.

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 parameters with 'id' described as 'The task ID', so the schema already documents the parameter fully. The description adds no additional meaning beyond what the schema provides, which matches 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 uses a specific verb and resource ('Get detailed information about a specific task'), making it clear this is a read operation targeting one task. It is easily distinguishable from siblings like teamleader_list_tasks, teamleader_create_task, and teamleader_update_task because it explicitly targets a specific existing task and requests 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?

The phrase 'about a specific task' implies this should be used when you need details for one task rather than a list, but it does not explicitly contrast with teamleader_list_tasks or state when not to use it. The usage context is inferable but not directly stated.

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

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

With no annotations, the description carries the burden of explaining behavior. 'Get' indicates a read operation and 'detailed information' suggests the return payload, but it does not disclose error behavior, permission requirements, or whether the entry is returned in full. It 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?

A single sentence with no filler; the description is appropriately sized for a simple getter tool. It communicates the core purpose immediately and every word contributes.

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 get operation, the description plus schema is mostly sufficient: the agent knows the resource, the input, and that detailed information is returned. It lacks explicit guidance on distinguishing from the list tool and does not describe return shape, but the low complexity makes this a minor gap.

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

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

The schema fully documents the only parameter, 'id', with the description 'The time tracking entry ID', so schema coverage is 100%. The tool description adds no extra parameter-level meaning beyond identifying the entry type, and 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 states a clear verb ('Get'), a specific resource ('time-tracking entry'), and signals a singular/detailed operation ('detailed information', 'specific'). This distinguishes it from the sibling list tool, teamleader_list_time_tracking, though it does not explicitly name that 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?

Usage is implied: it is the tool to use when you need details about one time-tracking entry, as opposed to listing entries. However, it does not explicitly say when to prefer this over teamleader_list_time_tracking or how to obtain the required id.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Link' implies a mutating action, but the description does not disclose what happens if the contact is already linked, whether the link replaces existing data, or what the response contains. This is a meaningful gap for a write 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 that states the core action first and then the optional modifiers. There is no wasted wording or redundant 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 relatively simple and the schema covers all parameters, but with no annotations and no output schema, the absence of behavior details (such as idempotency, error conditions, or return value) leaves gaps. It is adequate for a basic linking action but not fully complete.

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

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

Schema description coverage is 100%, so the schema already explains id, company_id, position, and decision_maker. The description adds only a slight restatement that position and decision-maker are optional, without introducing any new semantic meaning beyond the schema.

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

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

The description uses a specific verb+resource construction: 'Link a contact to a company.' It also names the optional fields (position and decision-maker flag), making the operation's scope clear. It does not explicitly contrast with the sibling teamleader_update_contact_company_link, but the action of linking is distinct enough from updating or unlinking.

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—whenever a contact should be associated with a company—but provides no explicit guidance about when to prefer teamleader_update_contact_company_link or teamleader_unlink_contact_from_company. No prerequisites or edge cases (e.g., already-linked contacts) are mentioned.

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

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

No annotations are provided, so the description carries the burden of disclosure. 'List' implies a read-only operation, and the mention of activity_type_id hints at the response contents, but the description does not explicitly state side effects, pagination behavior, or any other behavioral traits beyond what the schema already offers.

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

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

Two short sentences with no wasted words. The action is front-loaded, followed by the concrete use case. Every sentence earns its place.

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

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

For a simple list tool with two optional pagination parameters and no output schema, the description covers what it returns, why to call it, and the relevant ID field. Nothing essential is missing.

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

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

Schema description coverage is 100%: both page and page_size already have clear descriptions. The tool description adds no parameter-specific meaning, 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 states a specific verb and resource: 'List activity types', and the parenthetical '(task, meeting, call)' further specifies what counts as an activity type. This clearly distinguishes it from the many other list_* sibling tools like list_companies or list_products.

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 sentence 'Use to find activity_type_id when creating events' gives explicit context for when to call this tool. It doesn't mention exclusions or alternatives, but the resource is unique enough that the guidance is sufficient.

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 full burden of behavioral disclosure. The verb 'List' implies a read-only operation, and 'optional filtering and pagination' hints at the behavior. However, it does not explicitly state that it is safe/destructive-free, describe the response format, or mention any rate limits or permissions. This is a minimal but not misleading description.

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

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

A single, front-loaded sentence with no redundant words. It starts with the core action ('List companies from Teamleader Focus') and then adds the qualifying 'optional filtering and pagination'. Every word earns its place; no filler or repetition.

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

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

For a list tool with six optional parameters and no output schema, the description is adequate but slightly lean. It correctly identifies the resource and the general capability, and the schema covers parameter details. However, it does not explicitly mention that the result is a paginated list of company objects, nor any caveats like result limits. Given the simplicity of the tool, this is sufficient 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?

Schema description coverage is 100%, so all six parameters are already well-documented in the schema. The description only adds the generic phrase 'optional filtering and pagination', which does not provide additional meaning beyond the schema. Baseline 3 is appropriate because the schema handles parameter semantics fully.

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

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

The description clearly states a specific verb and resource: 'List companies from Teamleader Focus'. It distinguishes this from sibling tools like get_company (single company) and create/update/delete company operations. The phrase 'with optional filtering and pagination' further scopes the behavior, leaving no ambiguity 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?

There is no guidance on when to use this tool versus alternatives. It does not mention when to prefer list_companies over get_company, nor does it explain exclusions or prerequisites. The usage context is only implied by the name and description, not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden. It mentions optional filtering and pagination, which are behavioral traits, but it does not disclose output format, ordering, side effects (though a list operation is read-only), auth requirements, or any edge-case behavior. This is a minimal disclosure for a tool with no annotation support.

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

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

The description is a single, concise sentence that front-loads the core purpose. There is no wasted text; every word contributes to stating what the tool does.

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

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

With no output schema and no annotations, the description is expected to provide richer context. It fails to mention response structure, pagination behavior beyond the schema's max page size, filtering semantics, or any practical usage notes. For a tool with 5 optional parameters, this is insufficient to fully guide an agent.

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

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

The schema provides full documentation for all 5 parameters with descriptions (coverage 100%), so the description need not elaborate. The description's mention of 'optional filtering and pagination' maps to the parameters but adds no new meaning beyond what the schema already states. Baseline 3 is appropriate given 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 action (list) and resource (contacts from Teamleader Focus), which is specific enough to distinguish from get_contact and other list tools. However, it does not differentiate itself from sibling list tools beyond the resource name, but the resource is unambiguous.

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

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

The description implies usage for listing multiple contacts but does not explicitly state when to choose this over alternatives like get_contact or list_companies. No exclusions or alternative conditions are provided, leaving the selection to the agent's inference from tool names.

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 implies a read-only operation by using 'List' and mentions the output content (IDs and configuration), but it does not explicitly state that it is read-only, nor does it describe pagination behavior or any potential side effects. The description is adequate for a listing tool but lacks explicit safety declarations.

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

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

The description is two sentences, with the primary purpose front-loaded. It avoids redundancy and every phrase adds value: 'List custom field definitions', then the use case, then the content and context filter. There is no fluff 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?

Since there is no output schema, the description compensates by indicating what the tool returns (custom field IDs and configuration, including select field options). It also covers the context filter and mentions the variety of contexts. It does not explicitly discuss pagination, but the page and page_size parameters imply that. For a list operation with no annotations, this is reasonably complete.

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

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

Schema description coverage is 100%, so all three parameters are already documented. The description adds context about the 'context' parameter by listing the possible values and mentioning 'per context', which mirrors the schema's enum. It does not introduce new meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'custom field definitions', and elaborates on the purpose: discovering custom field IDs and their configuration, including select field options, per context. It also enumerates the contexts, which distinguishes it from all sibling tools since none other deals with custom field definitions.

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 explicitly says 'Use to discover custom field IDs and their configuration', providing clear when-to-use guidance. It does not mention alternatives, but no sibling tool offers similar functionality, so this is not a gap. It could be more explicit about when not to use it, but the purpose is sufficiently defined.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does state that the tool lists phases, sorts them by flow order, and supports an optional pipeline filter. However, it does not disclose pagination behavior or what fields are returned, which would be useful for an agent.

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

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

Two concise sentences with no filler. The main action and sorting behavior are front-loaded, and the use case is stated directly. Every sentence earns its place.

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

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

For a simple list tool with fully documented parameters, the description covers purpose, sorting, and filtering. It lacks explicit pagination defaults or response shape details, but the core information an agent needs to call it correctly is present.

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. The description adds the purpose of deal_pipeline_id ('Optionally filter by pipeline') and the overall use case, but it does not add meaningfully beyond the schema for page or page_size.

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

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

The description names a specific verb ('List'), a specific resource ('deal phases (stages)'), and a distinguishing detail ('sorted by their order in the flow'). It clearly differentiates this from sibling tools like list_deal_pipelines or list_deal_sources.

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

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

It explicitly states when to use this tool: 'Use to find phase_id for creating deals or moving them.' It also notes the optional pipeline filter. It does not mention alternatives or when not to use it, but the use case is clear enough.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It reveals that the response meta contains the default pipeline ID, which is helpful. However, it does not state that the operation is read-only, describe pagination behavior beyond the implicit page parameters, or mention any potential side effects. It is a simple list tool, but the lack of explicit read-only or error context keeps this at a baseline 3.

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, no filler. It opens with the core purpose, then immediately adds the valuable tip about the default pipeline ID and the intended use for finding IDs. Every word earns its place, and the structure is front-loaded for quick comprehension.

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

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

For a simple list tool with optional pagination and no output schema, the description is generally adequate but has gaps. It mentions the response meta but does not describe the structure of the pipeline objects (e.g., fields like id, name). The phrase 'pipeline/phase IDs' introduces ambiguity—it may suggest the tool returns phase IDs, when only pipelines are listed. This could lead an agent to make incorrect assumptions. A clearer response summary or disambiguation from list_deal_phases would improve completeness.

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

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

The input schema has 100% coverage for the two parameters, each with descriptions including defaults and max values. The tool description adds no additional parameter information beyond what the schema already provides. Since the schema does the heavy lifting, the description's contribution is neutral, so a baseline 3 is appropriate.

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

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

The description clearly states the action and resource: 'List deal pipelines.' It also adds the specific purpose of finding pipeline/phase IDs, and mentions the default pipeline ID in the response meta, which is a useful distinguishing detail. Out of the many sibling list tools, this one is uniquely about pipelines, so there is 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 says 'Use to find pipeline/phase IDs,' which gives a concrete scenario for when this tool is appropriate. It does not explicitly list when not to use it or name alternatives, but the instruction is actionable. The phrase 'pipeline/phase IDs' is slightly ambiguous because the tool only lists pipelines, not phases, which could mislead an agent into thinking it returns phase IDs directly. Still, it provides clear usage context.

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

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

With no annotations, the description carries the behavioral burden. 'List' and 'find source_id' imply a read-only operation that returns source identifiers, but it does not describe response shape, pagination behavior, ordering, or error conditions. It is not misleading, but it is minimally informative.

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

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

Two short sentences with no filler: the first names the operation and the second gives the actionable use case. It does not repeat schema details and is easy to scan.

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

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

For a simple list tool with optional pagination parameters and no required arguments, the description covers why and when to call it. The lack of an output schema is partially mitigated by the explicit source_id guidance, though response format details are not described.

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 page and page_size have clear descriptions with defaults and limits. The tool description adds no parameter-level meaning beyond that, so the baseline score of 3 is appropriate.

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

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

The description identifies the resource (deal sources), uses the clear verb 'list', and explains the practical purpose: finding source_id for deal creation/update. It does not explicitly differentiate from sibling list_* tools, but the resource name and stated use case make the intent unambiguous.

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

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

The description gives a clear context for use: 'Use to find source_id when creating/updating deals.' It does not mention exclusions or alternatives, but for a simple reference-data lookup this is sufficient guidance.

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

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

No annotations are provided, so the description carries the full burden. The description only states the action and purpose; it does not disclose whether the operation is read-only, any pagination behavior beyond parameter defaults, or the shape of the response. It is minimal and leaves behavioral traits to inference.

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 the action and resource front-loaded. It immediately states the purpose and the use case without any wasted words. Every sentence earns its place.

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

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

For a simple list tool with no output schema, the description adequately conveys what it does and why it would be used. It mentions finding department_id, implying the response contains this field. However, it does not describe pagination details beyond parameter defaults or any other return fields, but given the simplicity, this is sufficient.

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

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

The input schema provides 100% coverage for both parameters (page and page_size) with clear descriptions. The tool description does not add any additional parameter semantics beyond what the schema already states. Baseline of 3 is appropriate because the schema fully documents the 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 action (List) and resource (departments), clarifies that departments are company entities, and explicitly states the intended use case (finding department_id for invoices, quotations, projects, tax rates). This distinguishes it from sibling list tools and gives an agent a precise understanding of what it does.

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

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

The description provides a clear usage context by naming specific downstream uses (invoices, quotations, projects, tax rates). It implies when to use this tool, though it does not explicitly mention alternatives or when not to use it. The purpose is specific enough that an agent can select it correctly among many list 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 carry the full burden of behavioral disclosure. It only states that it lists events with filtering and pagination, but doesn't disclose nuances like whether this is a read-only operation (which is implied by 'list'), what the return format is, how pagination works beyond defaults, or any rate limits or authentication requirements. It describes the obvious behavior but not the deeper 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?

The description is a single, clear, and concise sentence that front-loads the core purpose (list events) and mentions optional filtering and pagination. It's appropriately sized and avoids unnecessary detail, though it could be slightly more explicit about the filtering parameters.

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 moderate complexity (6 parameters, all optional) and the lack of an output schema, the description is adequate but incomplete. It covers the basics (list, filter, paginate) but doesn't explain how to combine filters or what the response looks like. Without annotations, an agent might not know that the operation is safe or how many events are returned per page beyond max.

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 all 6 parameters with 100% coverage, so the baseline is 3. The description adds no additional parameter semantics beyond saying filtering exists, which is redundant with schema. It doesn't clarify how the date parameters interplay (e.g., if both start and end filters are needed) or provide examples of usage.

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 'list' and resource 'calendar events' from Teamleader Focus, and mentions filtering and pagination, which differentiates it from siblings like teamleader_get_event (singular get) and teamleader_create_event. However, it doesn't explicitly mention available filters, which are only in the schema.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It doesn't mention that this is a list operation as opposed to get_event for a single event, nor does it discuss any exclusions or prerequisites. No context is given about typical use cases or how it relates to sibling tools.

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

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

No annotations are provided, so the description bears the burden of behavioral disclosure. 'List' strongly implies a read-only operation, and stating the purpose adds some context. However, it does not mention pagination behavior, authentication, or whether the list is scoped by pipeline/deal phase. These are minor gaps for a simple lookup tool.

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

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

Two sentences with no filler. The core action and resource are front-loaded, followed immediately by the practical use case. Every clause contributes necessary information.

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

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

For a simple list tool with two optional pagination parameters and no output schema, the description is largely complete. It states what it lists and why it is used, including the key output field (reason_id). It does not describe the full response shape or pagination behavior, but that is a minor gap given the tool's simplicity.

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

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

Schema description coverage is 100%, with both page and page_size documented in the schema. The description adds no additional parameter 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 names a specific verb ('List'), a distinct resource ('lost reasons'), a scope ('for deals'), and the downstream purpose ('find reason_id when marking a deal as lost'). This clearly distinguishes it from sibling listing tools like list_deal_phases and list_deal_sources, so an agent can select it correctly.

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 explicitly tells the agent when to use this tool: when marking a deal as lost and needing a reason_id. It does not name alternative tools or give exclusions, but the use-case framing gives clear enough context for a simple reference-list tool.

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

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

No annotations are provided, so the description must disclose behavioral aspects. It does not mention pagination behavior, ordering, or whether the response includes full note content or just summaries. It also doesn't state any rate limits or authentication requirements. The description is consistent with the read-only nature implied by 'List', but lacks explicit behavioral detail.

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

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

The description is one concise sentence, front-loading the core purpose. It has no redundant phrases and is easy to parse.

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 list tool with only two required parameters and a complete schema, the description is adequate but misses guidance on pagination and return format. Since there is no output schema, the agent might need to know whether the response is a list of note summaries or full notes, which is not clarified.

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 'subject_type' as an enum with valid values and 'subject_id' as the entity ID. The description adds context that the subject can be a contact, company, deal, or project, but doesn't add further detail on pagination parameters or required combinations beyond the schema.

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

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

The description states a clear verb ('List') and resource ('notes') with a specific scope ('attached to a specific subject'), and provides examples of valid subject types. It clearly differentiates from sibling tools that create, update, or get notes, though it doesn't explicitly distinguish from other list tools like list_tasks.

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

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

The description implies when to use this tool (when you need notes for a given subject) but provides no explicit exclusions or alternatives. It does not mention that it only lists, not retrieves a single note, nor does it contrast with other list tools.

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

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

No annotations are provided, so the description carries the full burden. It states the tool lists categories and can filter by department, but doesn't disclose pagination behavior, default page size, or any other behavioral traits. The schema already covers parameters, so the description adds little beyond what's in 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 two sentences with no waste. It front-loads the main action and purpose, then adds the optional filter. Efficient and clear.

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

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

For a simple list tool with no required parameters and full schema coverage, the description is mostly adequate. However, it doesn't mention pagination behavior or what the response contains beyond product categories, which could be useful for an agent. The lack of output schema means the description could have added a bit more context about return values.

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. The description adds the purpose of the tool (finding product_category_id) and mentions the department filter, but doesn't add meaning beyond the schema's parameter descriptions. 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 tool lists product categories and explicitly mentions its purpose: finding product_category_id. It also notes an optional department filter. It doesn't explicitly differentiate from sibling tools, but the verb 'list' and resource 'product categories' are specific enough to distinguish it from other list tools.

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

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

The description implies usage: use it to find product_category_id, and optionally filter by department. It doesn't explicitly state when not to use it or mention alternatives, but the context is clear enough for an agent to know when this tool 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?

No annotations are provided, so the description carries the full burden. It states it lists products but does not mention pagination behavior, default sorting, or that it is a read-only operation. The schema conveys page/page_size but the description adds no behavioral detail beyond the purpose. This is adequate for a simple list tool 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 sentence with zero redundancy. It front-loads the core action and immediately links to a concrete use case. Every word earns its place.

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

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

For a simple list operation with no output schema, the description is mostly complete: it explains the purpose and points to the product_id use. Lacking behavioral details like pagination, filtering nuances, or return format, but given the simplicity and the fact that page/page_size are already in the schema, it is reasonably complete.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description does not add any additional meaning about how 'term' interacts with products or pagination behavior. No extra semantic value is provided over 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 (list products) and the specific purpose (find product_id for invoice/quotation line items), which distinguishes it from the sibling get_product. The verb 'List' and resource 'products' are specific and the intended use case is explicit.

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

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

The description provides a clear use case ('Use to find product_id...') which implies when to use it. However, it does not explicitly mention alternatives or when not to use it, though the sibling get_product is indirectly differentiated because get_product retrieves a single product. Lacks a formal when/when-not statement but the context is reasonably clear.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'optional filtering and pagination' but does not explicitly confirm read-only behavior, absence of side effects, auth requirements, or response structure. 'List' weakly implies a read operation, but this is insufficient without annotation support.

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

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

A single, efficient sentence with no filler. The action, resource, and key capabilities are front-loaded, and every word contributes to the intended 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?

With 8 optional parameters and no output schema, the description does not mention what the response contains or how filters like customer_id and customer_type interact. The agent can invoke the tool with zero parameters, but missing response context makes the definition incomplete for a tool with this parameter richness.

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 8 parameters are already documented individually. The description only adds the generic summary 'optional filtering and pagination,' which does not enhance meaning beyond what the schema provides.

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

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

States a specific verb ('List') and resource ('projects from the Teamleader Focus (next-gen) projects module'), clearly distinguishing it from sibling tools that get, create, update, or delete projects. The mention of the next-gen module adds further specificity.

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

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

The description implies usage through the verb and resource but does not explicitly state when to use this tool over alternatives like teamleader_get_project or teamleader_list_tasks. It offers no exclusions or alternative routing, leaving the agent to infer usage.

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

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

There are no annotations, so the description carries the full behavioral burden. It conveys that this is a read-only listing operation and that filtering and pagination are available, which are useful behavioral facts. However, it does not disclose response shape, default pagination behavior, potential scope limitations, or whether any side effects occur.

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 core action, the resource, the platform, and the main optional capabilities without redundancy.

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

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

For a simple list tool with five optional parameters, the description plus schema is mostly sufficient to invoke it correctly. However, the absence of an output schema and the lack of any return-format or filtering-combination guidance leaves some uncertainty. A slightly richer description mentioning that this is for batch retrieval while teamleader_get_task is for a single task would make it fully complete.

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

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

Schema description coverage is 100%, and all five parameters already have descriptive text covering meanings, defaults, and enum constraints. The description adds only a generic 'optional filtering and pagination' statement, which does not materially enhance what the schema already provides. 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 names a specific verb ('List'), a clear resource ('tasks'), and the domain ('Teamleader Focus'), so an agent can tell this apart from task mutation tools like teamleader_create_task or teamleader_update_task. It also signals filtering and pagination capabilities. It stops short of a 5 because it does not explicitly differentiate itself from sibling list tools or clarify whether it returns all tasks or a scoped subset.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention using teamleader_get_task for a single task, nor does it note any relationship to other task tools such as teamleader_list_notes or teamleader_get_task. 'Optional filtering and pagination' implies use cases but does not state them explicitly.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, and the description adds the purpose of finding tax_rate_id, which is useful. However, it does not explicitly state that no modifications are made, nor disclose any potential side effects, permissions, or pagination behavior beyond what the schema already covers. For a simple list tool, the description is adequate but leaves room for clearer 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 two sentences, front-loads the core action, and includes the purpose and optional filter. Every word earns its place, with no unnecessary filler. It is succinct and well-structured.

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

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

For a simple list tool with three optional parameters and no output schema, the description provides enough context to call it correctly: what it lists, why to use it, and an optional filter. It does not describe the response format (field names for tax_rate_id or other data), but the purpose statement implies the presence of tax_rate_id. The lack of output schema is partially mitigated by the stated use case. Overall, it is reasonably complete for the tool's simplicity.

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

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

The schema description coverage is 100%, with each parameter (page, page_size, department_id) having a description. The tool description adds no additional parameter meaning beyond repeating that department filtering is optional. It does not clarify the source of department_id (e.g., from teamleader_list_departments), but the schema already defines the filter. Baseline 3 is appropriate given 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 lists available tax rates and explicitly ties it to finding tax_rate_id for invoice and quotation line items. It uses a specific verb ('List') and a specific resource ('tax rates'), and is easily distinguished from the many sibling list tools by its unique resource type.

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 a clear use case: 'Use to find tax_rate_id for invoice and quotation line items.' This gives context on when to call the tool. It does not explicitly mention when not to use it or list alternatives, but given the tool's specific resource, differentiation is implicit. The optional department filter is also mentioned.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds useful inclusion detail ('with members and team lead'), but it omits pagination behavior, response shape, and filtering semantics beyond the parameter names.

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, well-structured sentence that front-loads the verb and resource and adds a meaningful qualifier in parentheses. 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 read-only list operation with fully documented parameters, the description conveys the essential result content. A minor gap is the lack of any indication of response shape, but this is a straightforward listing 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%: page, term, and page_size all have descriptions including defaults and max. The tool description adds no parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('teams'), and clarifies that results include members and team lead. It is clear enough to distinguish from sibling list tools by resource type, though it does not explicitly name any alternative.

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

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

There is no guidance on when to use this tool versus the many sibling list tools, no alternatives are mentioned, and no exclusion criteria are given. An agent gets no help deciding between list_teams and list_users or list_departments.

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 only mentions filtering and does not disclose pagination behavior, output format, permissions, or any side effects. This is a read-like operation, but that is not stated.

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

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

A single, concise sentence that is front-loaded with the action and scope. No wasted words, though it could add a bit more guidance without becoming 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?

With 10 parameters and no output schema or annotations, the description is too sparse. It lacks details on pagination, result format, or any nuances about filtering combinations, making it incomplete for confident usage.

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 all parameters have descriptions. The description adds no extra meaning 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 verb 'list' and resource 'time-tracking entries', with optional filters. It is distinguishable from siblings like get_time_tracking, but does not explicitly contrast with them.

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

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

The description mentions optional filters but gives no explicit guidance on when to use this tool versus alternatives like teamleader_get_time_tracking, or any exclusions. With many sibling tools, this is a significant gap.

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

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

No annotations are provided, so the description carries the full burden. It conveys read-only list semantics and the meaningful output (user IDs), but it does not disclose pagination behavior, term match scope, or response shape. This is adequate but leaves some behavioral gaps.

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

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

Two sentences with no filler. The main purpose is front-loaded, and the user-ID use case is stated in the second sentence. Every sentence earns its place.

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

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

For a simple list tool with no required parameters and no output schema, the description provides the resource, account scope, and a clear reason for calling it. Pagination and search parameters are already covered in the schema, so an agent can invoke it correctly with the information given.

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

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

The input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description does not add per-parameter details beyond pointing at user-ID lookup, which is useful context but not additional parameter semantics.

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

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

The description states a specific verb and resource: 'List users (co-workers) in the Teamleader account.' It also clarifies the intended output by saying the tool is used to find user IDs for responsible_user_id / assignee / owner fields, which distinguishes it from sibling list tools like list_contacts or list_teams.

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

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

The description gives a clear use case: 'Use to find user IDs for responsible_user_id / assignee / owner fields.' This tells an agent when to invoke it, though it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries the transparency burden. It signals a read-only listing operation through the word 'List' and implies the response contains work_type_id, which is useful. However, it does not disclose response shape details, pagination behavior, or any filtering semantics beyond what the schema already states.

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

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

The description is two short sentences with no filler. The core action is front-loaded in the first sentence, and the second sentence adds the actionable purpose. 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, unauthenticated-looking list operation with zero required parameters and full schema coverage, the description plus schema is nearly sufficient. It tells the agent what the tool returns the ID for, though a bit more detail about the output objects would make it fully complete given there is no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (page, term, page_size). The description adds the intent of finding work_type_id but no additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'List work types.' It also states the downstream use case explicitly—'Use to find work_type_id for tasks, events and time tracking'—which distinguishes this tool from the many other list_* siblings by naming exactly why an agent would call it.

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

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

The description gives clear context for when to call the tool: whenever a work_type_id is needed for tasks, events, or time tracking. It does not explicitly name alternatives or state when not to use it, but the purpose statement is enough for an agent to route to it correctly.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action 'remove' without detailing side effects, irreversibility, required permissions, failure conditions, or any impact on associated data. 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, well-structured sentence with no superfluous words. It front-loads the core action and target, making it immediately readable. Perfectly concise for the operation described.

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 removal operation with three required parameters and no output schema, the description is minimal but arguably sufficient to convey the tool's function. However, it lacks any mention of prerequisites, error behavior, or relationship to other project operations, and since there are no annotations, this leaves the agent without crucial contextual details.

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

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

The schema already provides full descriptions for all three parameters (project ID, customer ID, customer type enum). The description adds minimal semantic value beyond what the schema states, merely reiterating that the customer can be a contact or company. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action (remove), the resource (customer) and the target (project), and specifies that the customer can be either a contact or company. This distinguishes it from sibling removal tools like remove_project_owner or remove_project_deal, making the 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., the customer must already be attached), nor does it reference the inverse operation (add_project_customer) or any other related tools. Usage context is entirely left to inference.

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

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

There are no annotations, so the description carries the full behavioral burden. It correctly indicates an unlink rather than a delete, but it does not disclose potential side effects, idempotency, prerequisites, or permission requirements. This is minimally transparent rather than informative.

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, redundancy, or unnecessary context. Every word contributes to conveying the operation.

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

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

For a simple two-parameter operation with fully documented schema fields, the core invocation information is present. However, with no annotations and no behavioral context about side effects or reversibility, the description is adequate but not fully complete.

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

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

Schema description coverage is 100%: both 'id' and 'deal_id' already have clear descriptions in the input schema. The tool description adds no additional parameter-level meaning, so it remains at 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 uses a specific verb ('Unlink') with a concrete object ('a deal') and target ('from a project'), clearly stating the operation. It distinguishes itself from the sibling teamleader_add_project_deal and other project-related mutation tools.

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

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

The description implies when to use the tool: when a deal should no longer be linked to a project. However, it provides no explicit when-to-use/when-not-to-use guidance and does not mention the inverse operation add_project_deal or any alternative.

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

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

With no annotations, the description must carry the behavioral burden. It only states the removal action without disclosing side effects (e.g., what happens if the user is not an owner, whether ownership is fully removed, permission requirements, or response format). No output schema exists, so the agent has no guidance on expected results.

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, well-formed sentence with no redundant information. It is front-loaded with the core action and resource, and every word earns its place.

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

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

For a simple mutation with two self-explanatory parameters, the description covers the primary intent. However, it omits behavioral details (error handling, idempotency, permissions) and does not reference related tools. Given the simplicity, this is minimally adequate but not rich.

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% for both parameters (id and user_id), and each has a clear description. The tool description adds nothing beyond what the schema already conveys, so the baseline of 3 applies. No additional parameter context is provided.

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 (remove) and the resource (user as owner of a project). It distinguishes from the sibling add_project_owner by the verb and directly maps to the tool's name. The scope is unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives like teamleader_assign_project or teamleader_add_project_owner. It does not mention prerequisites, idempotency, or any exclusions. The agent is left to infer context from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action (unlink) but doesn't disclose side effects, such as whether the quotation is deleted, whether the project is modified, reversibility, or permission requirements. 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?

A single sentence with zero waste. The action and both resources are stated clearly and front-loaded.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It doesn't explain what happens after unlinking, whether the operation is idempotent, or any error conditions. The schema covers parameters, but the behavioral context is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('id' as project ID, 'quotation_id' as quotation ID to unlink). The description adds no additional meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description 'Unlink a quotation from a project' uses a specific verb ('unlink') and names both resources (quotation, project), clearly distinguishing it from the sibling 'teamleader_add_project_quotation' and other project-related tools. It is concise and unambiguous, though it doesn't explicitly name the sibling tool.

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