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. 'Get' clearly implies a read-only operation, and there are no apparent side effects, but the description does not mention error behavior, authorization requirements, or whether the id refers to an asset id, agent id, or some other identifier.

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 fluff. It front-loads the verb, resource, and key scoping detail ('by id'), which is exactly what an agent needs at a glance.

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-resource lookup with one required parameter, the description is minimally adequate. However, it lacks any explanation of the return value or the meaning of 'id' in context, and there is no output schema to compensate for that missing information.

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

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

With 0% schema description coverage, the description must compensate for the schema's silence on 'id'. Saying 'by id' mostly restates the parameter name and adds little meaning. It does not clarify what kind of id this is, what format it takes, or how it relates to the 'agent (managed device)' wording.

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 operation ('Get'), the resource ('a single agent (managed device) asset'), and the lookup mechanism ('by id'). It is immediately distinguishable from sibling tools like gorelo_list_assets, which list assets rather than fetch a single one.

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

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

The usage context is implied: use this tool when you need one specific asset by its id rather than a list of assets. However, there is no explicit comparison to gorelo_list_assets or gorelo_list_custom_assets, nor any guidance on when not to use this 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states the operation without mentioning potential errors (e.g., 404 if not found), authentication requirements, response format, or whether the operation is read-only (though 'Get' implies it). No behavioral traits are disclosed beyond the basic action, leaving the agent to assume typical get-by-id semantics.

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

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

The description is a single, efficient sentence that front-loads the core purpose. There is zero extraneous wording, and it conveys the essential information without redundancy. It is appropriately concise for a simple get-by-id 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?

The tool is simple (one parameter, no nested objects, no output schema), and the description covers the basic purpose. However, it lacks any information about error handling, response structure, or what constitutes a 'client' object. Given the absence of annotations and output schema, an agent might need more context to fully interpret the result, but the description is adequate for a basic read operation. The missing details lower completeness but not to a critical level.

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 describes a single parameter 'id' of type number with no description (0% coverage). The description says 'by id' but does not clarify that this is the client's unique identifier, nor does it explain the format or any constraints. It adds minimal meaning beyond the parameter name, and with 0% schema coverage, the description should have provided more context about the id.

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

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

The description clearly states the action (get) and the resource (a single client) with a specific identifier (by id). It distinguishes itself from sibling tools like gorelo_list_clients, which lists multiple clients, and gorelo_get_contact, which targets contacts. The phrase 'single client' makes the scope explicit, 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 that this is the appropriate choice when you have a client ID and need one client's details, nor does it reference gorelo_list_clients for retrieving all clients. An agent must infer usage from the name and siblings, which is not 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?

With no annotations, the description relies on the verb 'get' to signal a read-only operation with no side effects. It does not disclose what happens if the id does not match a contact or what fields the response will contain, but for a simple getter these omissions are relatively minor.

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 entire description is one short sentence, front-loaded with verb and resource, with no filler or redundant restatement of the tool name.

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

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

For a one-parameter getter with no output schema, the description plus the schema's required id field is sufficient for selection and invocation. It could add what is returned or not-found behavior, but those are not essential to making the call.

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's id parameter has no description (0% coverage), so the phrase 'by id' is the only clue that the required number is the contact's unique identifier. This adds just enough meaning to invoke the tool, but it does not elaborate on id format or how to obtain it.

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

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

The description uses a specific verb ('get') and identifies the resource ('single contact') and the access key ('by id'). This clearly differentiates it from the sibling gorelo_list_contacts, which returns a list rather than one record.

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 only usage cue is the phrase 'by id,' which implies the tool is appropriate when the caller already has a contact identifier. It does not explicitly mention that gorelo_list_contacts should be used to discover ids or state any exclusion conditions, so guidance is implied rather than explicit.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states it returns 'full detail', without mentioning that it is read-only, what happens on missing/invalid IDs, error handling, or any potential cost/rate implications. The description is minimal and does not add behavioral context beyond the obvious.

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

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

The description is a single short sentence, which is highly concise and front-loaded with the core purpose. However, it is terse to the point of being under-specified, but that is a completeness issue rather than a structure issue. It earns a 4 for efficiency.

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 operation, the description is minimally adequate but lacks important context such as the expected return format, whether it is read-only, or any error behavior. With no output schema and no annotations, more detail would help an agent understand what 'full detail' entails and how to handle edge cases.

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 100% coverage for the single parameter (ticketId with 'Ticket id (UUID).'). The description's 'by id' adds no new semantic meaning, so it does not elevate beyond the schema's clarity. 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 ('Get') and the resource ('a single ticket by id'), with 'full detail' indicating the richness of the response. It is distinct from sibling tools like gorelo_list_tickets (which lists) and gorelo_get_ticket_comment (which targets a comment), though it doesn't explicitly call out the difference.

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. There is no mention of when to prefer gorelo_list_tickets or any other sibling, nor any context about prerequisites such as having a valid ticket ID. The usage context is entirely implied.

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

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 conveys that the operation is a read (via 'Get') and mentions the returned data (approvers, computed status), but it does not disclose error handling, authentication prerequisites, or any potential side effects. This adds some context beyond the name but leaves key behavioral aspects unaddressed, so a 3 is appropriate.

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

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

The description is a single, compact sentence that front-loads the action and resource, then adds key output information. There is no redundancy or extraneous detail, making it highly concise 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?

The tool is simple (2 parameters, no output schema), and the description covers the core purpose and key return elements. However, it omits details like error behavior, response structure beyond the two mentioned fields, and any prerequisites. Given the lack of output schema and annotations, the description is adequate but not fully complete, so it earns a 3.

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

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

Schema coverage is 0%, so the description must compensate for parameter documentation. It implies that ticketId and approvalId identify the approval within a ticket but provides no details on their format, scope, or how to obtain them. The description adds only minimal relational context, which is insufficient for complete parameter semantics. Hence a score of 2.

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 'single approval on a ticket', and it explicitly mentions what is included (approvers and computed status). This clearly distinguishes it from sibling getter tools like gorelo_get_ticket, which operate on different resources. 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 usage when a single specific approval is needed, but it does not explicitly state when to prefer this over alternatives or when not to use it. Since no other approval-related tools exist among siblings, the guidance is implicit rather than explicit. This meets the 'implied usage' level, warranting a 3.

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

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

With no annotations, the description carries the full behavioral burden. It adds a meaningful behavioral detail: the response includes the full BodyHtml and omits the BodyTruncated flag. It does not cover error handling or authentication, but for a simple read operation this is reasonably transparent.

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

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

Two short sentences, with the core purpose front-loaded and the return-value detail added in the second sentence. Every word contributes, with 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 simple single-resource getter with two obvious parameters, the description is nearly complete. It states the exact scope and the key output characteristic (full BodyHtml). It could mention the absence of an output schema, but the description already tells the agent what to expect in the response.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain what ticketId and commentId represent beyond their names or how to obtain them. The resource name implies ticket and comment identifiers, but no format, source, or relationship guidance 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?

Uses a specific verb and resource: 'Get a single comment on a ticket.' It is immediately distinguishable from sibling gorelo_list_ticket_comments, which retrieves multiple comments, and from gorelo_get_ticket, which targets the ticket rather than the comment.

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

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

The description implies the use case: retrieve one specific comment by ID rather than listing all comments. However, it does not explicitly state when to choose this tool over get_ticket or list_ticket_comments, nor does it mention any prerequisites or exclusions.

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

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

No annotations are present, so the description must carry the full behavioral burden. It communicates a read/get operation but omits what happens when the id does not exist, whether additional permissions are needed, or what the returned object looks like.

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

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

One short, front-loaded sentence with no filler or redundancy. 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 one-parameter getter, the minimal description is usable: pass an id and get an entry. However, with no output schema and no annotations, it leaves unspecified the response shape and error behavior, so it is only minimally complete.

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

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

The schema provides only 'id' as a required number with no description coverage, and the description's 'by id' largely restates that parameter name. It does not add guidance on where the id comes from, accepted formats, or any special value 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 uses the specific verb 'Get' and identifies the exact resource ('a single time entry') plus the selection criterion ('by id'), so it is immediately clear what the tool does. This also distinguishes it from the sibling list tool gorelo_list_time_entries.

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 implicitly suggests using this tool when you already have a specific time-entry id, but it never states when to prefer it over alternatives or when not to use it. No sibling comparisons or exclusions are provided.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the listing is cursor-paginated and ordered by newest-created first, which are non-obvious and important behaviors. It does not mention read-only semantics, but that is often inferred from 'list'. It also does not describe potential side effects, but as a list operation, side effects are unlikely. The disclosed pagination and ordering add real value 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, compact sentence that front-loads the primary purpose and then adds key behavioral details (pagination, ordering). Every word earns its place; there is no fluff or redundancy. It is optimally sized 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?

Given the tool's complexity (9 parameters, no output schema), the description is somewhat thin. It explains pagination and ordering but does not mention the filtering capabilities, which are crucial for effective use. There is no mention of common use cases, how to combine filters, or what the response contains. The description is adequate for a simple list tool but falls short for a tool with this many parameters and 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 67%, meaning several parameters (query, clientIds, statusIds) lack descriptions. The tool description provides no additional parameter semantics, such as how filters interact or what query matches. It does not compensate for the schema gaps, leaving agents without guidance on how to use the filtering parameters effectively. This is a significant gap for a tool with 9 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 verb 'List', the resource 'agent (managed device) assets', and the scope 'for the service provider'. It also adds pagination and ordering details. It distinguishes from sibling tools like gorelo_get_asset (singular) and gorelo_list_custom_assets by specifying the asset 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 implies this tool is for listing assets, but it does not explicitly mention when to use it versus alternatives or any exclusions. It lacks guidance on when to use gorelo_get_asset instead, or how filtering parameters relate to use cases. The purpose is clear enough that an agent can infer basic usage, but there is no explicit routing or alternative guidance.

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

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

With no annotations, the description carries the burden of behavioral transparency. The verb 'list' clearly indicates a read-only operation, and the description adds no misleading claims. While it doesn't explicitly state 'does not modify data' or discuss permissions/rate limits, the simple read-only nature is self-evident from the wording, and the added usage context provides meaningful behavioral insight.

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 zero waste. The first sentence states the core purpose; the second adds a critical usage tip. The description is front-loaded 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 zero-parameter list tool with no output schema, the description is nearly complete. It tells what the tool lists, the context (configured for the service provider), and how to apply the result (use id as BillingRoleId). It could explicitly mention that the response contains role objects with id and name, but this 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?

The input schema has zero parameters, so the baseline for parameter semantics is 4. The description adds no unnecessary parameter detail, and the schema coverage is 100% (vacuously). There is nothing here that needs compensation.

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

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

The description clearly states the tool lists billing roles for the service provider, using a specific verb ('list') and resource ('billing roles'). It also immediately explains the purpose of the result (using the role's id as BillingRoleId when logging time), which distinguishes it from sibling list tools like gorelo_list_ticket_statuses or gorelo_list_clients.

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 this tool's output is needed: 'Use a role's id as BillingRoleId when logging time against a ticket.' It implies this tool should be called before time-entry creation, which is clear usage context. It doesn't mention exclusions or alternatives, but there are no sibling billing-role tools, so this 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 present, so the description carries the full burden of behavioral disclosure. It implies a read-only action with 'List', but says nothing about pagination, ordering, error behavior, permissions, or the shape of the returned locations. This is a significant transparency gap 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?

A single, direct sentence front-loads the verb and object with no redundant words. It is appropriately sized 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?

Given a simple one-parameter list tool with no output schema and no annotations, the description is under-specified. It lacks any mention of return value format, pagination or limits, and possible edge cases, so an agent would not know what response to expect.

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 only defines clientId as a required number with no description (0% coverage). The description adds 'for a given client', which clarifies that clientId identifies the client, but this mostly restates the parameter name and does not explain how to obtain or format clientId or what a 'location' is. The description barely compensates for the missing schema documentation.

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

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

The description states a specific operation (List) and resource (locations) with an explicit scope (for a given client). This clearly distinguishes it from siblings like gorelo_list_clients or gorelo_get_client, since no other sibling targets locations.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as gorelo_get_client or gorelo_list_clients. It implies a clientId is needed, but does not state when this tool should be preferred or when it should not be used.

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 disclosure burden. It does disclose cursor-based pagination and ascending client-id ordering, which are useful behavioral traits. However, it does not state whether the operation is read-only, what the response shape looks like, or how filters combine, leaving behavioral coverage partial.

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

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

The description is a single sentence with no wasted words. It front-loads the resource and verb, then adds the two most important behavioral details: cursor pagination and sort order.

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

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

For an 8-parameter list tool with no output schema and no annotations, this description is too thin. It omits filter semantics, response shape, and usage context, so an agent may still struggle to invoke it correctly for non-trivial use cases.

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 6 of 8 parameters, but query and statusIds have no descriptions. The description itself adds no parameter-level meaning and does not clarify these two ambiguous fields, so it fails to compensate for the missing schema documentation.

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

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

The description names a specific verb ('List'), a specific resource ('clients'), and a scope ('for the service provider'), while also adding pagination and sort-order details. This makes it unambiguous against siblings like gorelo_get_client and gorelo_list_client_locations.

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 siblings such as gorelo_get_client or gorelo_list_client_locations. No conditions, exclusions, or alternatives are mentioned, so usage is only implied by the tool name and verb.

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 transparency burden, and it does disclose meaningful behavior: cursor-based pagination, a stable sort order ('sorted by contact id ascending'), and scope to the service provider. It does not describe the result envelope or any response details, but 'List' clearly signals a read-only 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?

One clean, front-loaded sentence states the verb, resource, pagination, filtering, and ordering with no filler or repetition. Every clause earns its place and an agent can extract the core contract immediately.

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

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

For a tool with 10 parameters, no annotations, and no output schema, the description is informative but not fully complete. It leaves the meaning of the full-text query and multi-value filters implicit, and it does not describe the result shape, though the input schema mitigates some of this.

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

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

The schema already documents 7 of 10 parameters, and the description adds only the default ordering and the client-filter intent. Parameters like query, clientIds, and statusIds lack schema descriptions and are not clarified here, so the description does not fully compensate for those gaps.

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

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

The description opens with a specific action and resource, 'List contacts', and adds concrete behavioral detail: scope ('for the service provider'), pagination mode, optional client filtering, and sort order. This makes it clearly distinguishable from siblings such as gorelo_get_contact and gorelo_list_clients without opening their schemas.

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 'optionally filtered by client' implies a common use case, and 'cursor-paginated' signals use for paging through result sets. However, the description never names alternatives or states when not to use this tool, so the usage guidance is only implicit rather than explicit.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It does disclose that this is a read-only listing operation, that each result includes service lines, and that pagination is cursor-based. It does not mention authentication, rate limits, ordering, or how the clientIds filter affects results, which 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?

The description is a single compact sentence with no filler: it states the action, the result shape, and the pagination mode upfront. Every segment earns its place, and an agent can absorb the core behavior immediately.

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

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

For a simple optional-parameter list endpoint with no output schema, this description covers the main call shape and return composition. It does not explain the filtering semantics of clientIds or the structure of service lines, so it 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?

The schema documents cursor and pageSize, and the phrase 'cursor-paginated' reinforces the cursor parameter's role. However, clientIds has no schema description and the description does not explain that it filters contracts by client, leaving one of three parameters meaningfully under-specified.

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

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

The description opens with a specific verb and resource, 'List billing contracts', and adds that each contract includes its service lines and is cursor-paginated. This clearly distinguishes it from the sibling tools, none of which target contracts.

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 'List billing contracts' clearly signals when to use this tool: when the agent needs a paginated collection of billing contracts. There are no competing contract-listing siblings or exclusion conditions, so explicit when-not-to-use guidance is unnecessary.

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. It discloses pagination behavior and ordering, and 'List' implies a read-only operation, but it does not explicitly state safety/no side effects, authentication requirements, or potential limitations. It adds useful context but not a complete behavioral 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?

A single front-loaded sentence states the action, resource scope, pagination, and ordering with no filler. Every phrase earns its place.

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

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

Given eight optional parameters, no annotations, and no output schema, the one-line description covers core purpose, pagination, and ordering but omits filter combination semantics and response shape. Agents may still need to infer how query, clientIds, and time filters interact.

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 75%, so the schema documents most parameters. The description adds pagination/ordering context relevant to cursor and pageSize, but it does not clarify the two undocumented parameters, query and clientIds. Their names and types provide partial meaning, but the description offers no extra semantic detail.

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

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

The description uses a specific verb ('List'), names the resource ('custom (non-agent) assets for the service provider'), and includes distinguishing traits (cursor-paginated, newest-created first). This clearly differentiates it from sibling tools like gorelo_list_assets and gorelo_list_clients.

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 qualifier 'custom (non-agent)' implies this tool is for non-agent assets and not the general gorelo_list_assets, but it never explicitly says when to use this tool versus siblings or when not to use it. No alternatives or exclusion conditions are named.

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

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

The word 'List' conveys a read-only, non-destructive operation, which is meaningful since no annotations are provided. However, it does not disclose any additional behavior such as pagination, ordering, whether inactive groups are included, or permission requirements. This is acceptable but minimal.

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

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

One concise sentence that leads with the action and identifies the resource and scope. Every word earns its place, and there is no redundant or boilerplate content.

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

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

For a parameterless list tool, the description fully states what the tool returns and its scope. There is no output schema, and the description could mention return shape or pagination, but the core information needed to invoke 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 input schema has zero parameters, so there is nothing for the description to clarify. The description does not need to add parameter semantics, and the baseline of 4 is appropriate for a parameterless tool.

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

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

The description uses a specific verb ('List'), names the exact resource ('technician groups'), and adds scope ('configured for the service provider'). This clearly differentiates it from sibling list tools for tickets, clients, users, assets, and other resources.

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: use this tool to retrieve the provider's technician groups. There is no sibling tool for groups, so no routing ambiguity exists. It doesn't explicitly state when not to use it, but that's not necessary here.

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 and discloses cursor pagination, oldest-first default ordering, and the filter narrowing behavior. It does not cover authentication, rate limits, or return format, but these are less critical for a read-only listing 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?

Two concise sentences with no filler. The most important information—what the tool lists—is front-loaded, followed by pagination and filter behavior in a logical order.

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

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

For a 7-parameter tool with no annotations and no output schema, the description covers the main usage pattern well but omits several parameter semantics and any return-shape hint. An agent could call it correctly for common cases but would have to infer details for pagination and sorting options.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for ticketId, cursor, conversationType, and conversationId, and implies sortOrder through 'oldest-first'. However, pageSize, sortBy, and valid conversationType values remain undocumented, leaving clear gaps.

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 an explicit verb and resource: 'List the comments on a ticket'. The plural 'list' clearly distinguishes it from the singular sibling gorelo_get_ticket_comment, and the added pagination/order details make the scope unmistakable.

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 concrete selection guidance by explaining three filter levels: no filter, conversationType alone, and conversationType plus conversationId. It does not explicitly name alternative tools or state when not to use this tool, so exclusions are left implicit.

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 reveals a non-obvious behavior: Public/Private conversations return a null Id while Side/Approval conversations return a real Id. This is meaningful and goes beyond a simple 'list' statement, though it omits auth or rate-limit 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?

Two sentences with no filler: the first states the operation, the second provides the key Id behavior. It is front-loaded and 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 one-parameter read/list tool with no output schema, the description covers the essential call behavior and even tells the agent how to use the returned conversationId downstream. It does not enumerate all return fields or pagination, but those are not essential for invoking the tool correctly.

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

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

Schema description coverage is 0%, and the description does not explain ticketId semantics, format, or how to obtain it. The parameter name is self-evident, but the description fails to compensate for the complete lack of schema-level 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?

States a specific verb and resource: 'List the conversations on a ticket.' It further distinguishes conversation subtypes (Public/Private vs Side/Approval) and their Id behavior, making it clear how this tool relates to other ticket tooling.

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 by noting that Side/Approval conversations return an Id usable as conversationId on the comments endpoint, but it never explicitly states when to choose this tool over siblings or when not to use it. Guidance is present but indirect.

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 and discloses useful traits: cursor-based pagination and default sort order (updatedOn desc). It does not mention response shape or rate limits, but for a read-only list endpoint the provided behavior is reasonably transparent.

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 compact sentence that front-loads the core verb and resource, then immediately gives pagination, default sort, and the filter catalog. Every clause adds information and there is no filler.

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

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

For a 17-parameter list tool with no output schema, the description covers the core purpose, pagination, default ordering, and nearly all filter dimensions in a compact form. It could add a note about return shape or referencing sibling list endpoints for IDs, but an agent has enough context to invoke it 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 description coverage is only 59%, and the description compensates by summarizing filter categories that map to many sparsely documented ID parameters: status, client, priority, type, assignee, contact, tag, group, keyword, and date range. It leaves cursor, pageSize, and sort controls to the schema, which already documents them.

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

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

The description opens with a specific verb and resource: 'List tickets for the service provider.' It also adds pagination behavior and names the distinct list/filter operation, which separates it clearly from singular or metadata siblings like get_ticket and list_ticket_statuses.

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

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

The description makes the intended use clear: listing and filtering tickets with many available dimensions, plus the default sort order. It does not explicitly name gorelo_get_ticket as the single-ticket alternative, so it stops just short of full exclusionary guidance.

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

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

With no annotations, the description must carry behavioral context. It signals a read-only list operation and adds the 'configured for the service provider' scoping detail, but it does not disclose return format, pagination, or whether inactive or archived statuses are included. This is reasonable for a simple list but leaves some behavior unstated.

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

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

A single short sentence with no filler, front-loaded with the verb and resource. It is appropriately sized for a zero-parameter list tool 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, zero-parameter, read-only list, the description identifies the resource and scope with enough clarity to invoke the tool. The lack of return-value or ordering details is a minor gap, but the low complexity and absent output schema make the description mostly 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 tool has zero parameters, so the schema already covers everything about inputs. The description correctly focuses on the resource and scope rather than inventing parameter details, matching the baseline expectation for a no-parameter tool.

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

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

States a specific action ('List'), a specific resource ('ticket statuses'), and a scope ('configured for the service provider'), which distinguishes it from sibling tools like gorelo_list_ticket_types and gorelo_list_ticket_tags. There is no ambiguity about what the tool operates on.

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

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

No guidance is given on when to use this tool versus alternatives such as list_ticket_tags, list_ticket_types, or get_ticket. Any usage context must be inferred entirely from the tool name and sibling list, so the description does not help agents choose 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?

With no annotations, the description must carry the behavioral burden. 'List' implies a read-only operation and 'configured for the service provider' adds a scoping detail, but nothing is said about response format, pagination, or permission requirements. It is adequate for a simple no-parameter list operation 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, focused sentence with no filler or redundant phrasing. It front-loads the action and resource and earns every word.

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

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

For a zero-parameter list operation, the description is mostly complete: it states what is listed and at what scope. A small gap is the lack of any indication of return shape, but the simplicity of the tool lowers the burden.

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

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

The tool accepts zero parameters, so parameter semantics are trivially complete and the baseline of 4 applies. The description correctly implies there is nothing to configure beyond calling the tool.

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

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

The description states a specific verb ('List') and a specific resource ('ticket tags'), and adds a clear scope: 'configured for the service provider.' This is sufficient to distinguish it from sibling tools such as gorelo_list_ticket_statuses and gorelo_list_ticket_types.

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 alternatives or exclusions are mentioned, and there is no explicit when-to-use guidance. The use case is implied by the resource type and scope, but the description does not help an agent choose between this and related ticket metadata 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?

The description conveys a read-only listing operation, which is the core behavior, and no annotations are provided. However, it does not mention potential pagination, ordering, active-only filtering, or any service-specific caveats, leaving some behavioral ambiguity.

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. Every word contributes meaning, and it is appropriately sized for such a simple, parameterless tool.

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

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

For a zero-parameter list tool with no output schema, the description gives the essential purpose and scope. It is brief but sufficient; missing details like the shape of returned ticket types are likely not critical for invoking the tool correctly.

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

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

The input schema has no parameters, so the description is not required to elaborate on parameter meanings. The zero-parameter baseline of 4 applies, and the description does not introduce any conflicting or confusing parameter-related 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 action ('List') and the specific resource ('ticket types') plus the scope ('configured for the service provider'). It is distinguishable from sibling tools like list_ticket_statuses and list_ticket_tags by the resource noun, though it does not explicitly name those alternatives.

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

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

No guidance is given about when to use this tool versus related sibling tools. There is no indication of whether to prefer this over list_ticket_statuses or list_ticket_tags, nor any context about prerequisites or filtering.

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 disclosure burden. It does disclose pagination and optional filtering, but it omits response shape, ordering, default behavior with no filters, and any authorization requirements. This is moderate disclosure for a read-only-style list 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?

Single sentence with no filler. The core action is front-loaded, followed by pagination and filtering details, and every phrase carries useful meaning.

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 14 optional parameters and no output schema, the description covers the essential list behavior, scope, pagination, and filtering intent. However, it does not describe the return value shape, ordering, or how filters interact, leaving meaningful gaps for an agent choosing how to construct a request.

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 descriptions cover only 8 of 14 parameters (57%), leaving the six array filter parameters undocumented in the schema. The description adds that filters 'narrow' results but does not clarify how multiple filters combine or their default semantics. Partial compensation for the schema gaps.

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 action and resource: 'List logged time' across tickets and tasks, which distinguishes it from sibling tools like gorelo_get_time_entry. The description also mentions pagination and filtering, making the operation clear.

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

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

The 'List... cursor-paginated... narrowed by any of the filters' phrasing implies a bulk retrieval use case, but there is no explicit guidance on when to use this tool versus gorelo_get_time_entry or other listing tools. No when-not-to-use or alternative routing is provided.

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

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

With no annotations, the description carries the behavioral burden. It does disclose useful traits beyond the schema: 'cursor-paginated' and 'sorted by user id ascending' are real behavioral details. However, it does not address read-only safety, authentication, rate limits, or response shape, though 'list' does imply a read 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 entire description is one information-dense sentence with no filler. Each clause adds value: the resource type, the scope, the pagination mode, and the sort order are all front-loaded and immediately useful.

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-oriented list tool with zero required parameters, the description covers the essential operational details: what is listed, for whom, how pagination works, and the sort order. It does not describe the return envelope's cursor field, but that is a minor omission given the tool's simplicity and the lack 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 all parameters are already well documented: cursor is described as opaque and used from a previous page, and pageSize has clamping/default information. The description's 'cursor-paginated' loosely reinforces that, but it adds no new semantic detail 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 ('List') plus a clear resource ('users (technicians)') and scope ('for the service provider'), so an agent can immediately tell what the tool does. It also states pagination and ordering, which further distinguishes it from the many other list tools like gorelo_list_clients or gorelo_list_contacts.

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 resource label makes the intended use imply 'when you need users/technicians,' but the description never explicitly states when to use this tool versus alternatives or mentions any exclusions. It provides no direct guidance about sibling tools or scenarios where a different list tool would be more 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?

There are no annotations, so the description carries the disclosure burden. 'List' implies a read-only operation and the 'configured for the service provider' clause scopes the data, but the description does not mention return format, pagination, authorization, or other behavioral details. This is acceptable for a simple list tool but not fully transparent.

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 main purpose is stated first, and the actionable instruction about using the id is concise and immediately useful.

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, no-output-schema list tool, the description is nearly complete: it identifies what is listed, its scope, and how the result should be used. It could have explicitly differentiated from gorelo_list_ticket_types, but the time-logging hint already provides enough context.

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

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

The tool has zero parameters, so there is nothing to document beyond the schema. The description adds useful semantic context about how the returned work type id is consumed, which is 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 action ('List') and resource ('work types configured for the service provider'), and it explains the purpose of the returned ids: use one as WorkTypeId when logging time. This clearly distinguishes it from related list tools like gorelo_list_ticket_types.

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 usage context: fetch work types when you need a WorkTypeId for logging time against a ticket. It does not explicitly state when not to use this tool or name alternatives, but the context is strong enough for an agent to select it appropriately.

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