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

No annotations are provided, so the description carries the burden of explaining behavioral impact. It mentions the scope 'crm:write', which indicates an authorization requirement, but it does not disclose what approving does to the lead, whether it is reversible, or what side effects occur. For a state-changing action, this is a meaningful gap.

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

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

The description is a single compact sentence that includes the action, the HTTP endpoint, and the required scope. It is front-loaded and contains no filler, so every part 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 tool with one well-documented integer parameter and a direct approval action, the description conveys the essential invocation details: what it does, the endpoint, and the required scope. It does not describe return values or post-approval effects, but those are less critical for correct invocation of this simple 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?

The input schema already fully documents the single required parameter ('id') with a 'CRM lead id' description, so schema coverage is 100%. The description does not add anything about the parameter 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 states the action ('Approve a CRM lead') and the resource, and adds the exact HTTP endpoint. It is unambiguous, but it does not explicitly differentiate from the sibling reject-crm-lead, even though the opposite meaning is implied by the verb.

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 alternatives. It does not mention reject-crm-lead, get-crm-lead, or any condition that would make approval the right choice. The usage is only implied by the tool's name and one-line 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?

The destructiveHint annotation already communicates destructive behavior. The description adds the HTTP method and the required 'customers:write' scope, which is useful context, but it does not explain side effects such as reversibility or impact on associated data.

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 short sentence that leads with the primary action and includes the endpoint and permission scope. Every element 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 single-parameter destructive action with a destructiveHint annotation and no output schema, the description plus schema is nearly sufficient. It could add a note about what archiving does to the customer, but the current definition gives enough to select and invoke the tool correctly.

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

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

The input schema fully describes the single 'id' parameter, so the description does not need to add parameter detail. The description provides no additional semantic information beyond the schema, matching the baseline for fully covered 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 ('Archive') and a clear resource ('customer'), and further disambiguates with the exact HTTP endpoint. It distinguishes archive from update or delete operations among the sibling 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 is given about when archiving is appropriate versus alternatives like updating or deleting a customer. There is no mention of use cases, prerequisites, or exclusion criteria, so an agent must infer usage from the tool name.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that this is a PATCH mutation and that members:write permission is required, which is useful. It does not describe side effects, reversibility, or behavior for invalid role values, so transparency is only 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 compact sentence that front-loads the purpose and packs in the HTTP method, resource path, and required scope. There is no redundant or filler text.

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

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

For a simple two-parameter mutation with no output schema, the description plus schema covers what the tool does, what the parameters mean, and the required permission. It omits response details and error behavior, but given the tool's simplicity this is not a major 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 coverage is 100% and both parameters have clear descriptions: id is the member user id and role is the new team role name. The description adds no parameter-level detail beyond what the schema already 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 states a specific action and resource: changing a member's role, and it includes the exact HTTP method and path. This clearly distinguishes it from sibling member tools like list-members, get-member, and invite-member.

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

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

The purpose itself implies when to use it: when a member's role needs to be changed. However, there is no explicit guidance about alternatives, prerequisites, or when not to use this tool. The 'Scope: members:write' line is auth-related rather than usage 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 behavioral burden. It does disclose that this is a POST/write operation and states the required scope 'sales:write', which adds useful context. However, it omits side effects, response behavior, validation rules, or reversibility.

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

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

The description is compact and front-loaded: it states the action, resource, endpoint, and auth scope in two clauses. Every element earns its place 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 mutation tool with no annotations, no output schema, and seven parameters, this description is too lean. It leaves the agent without clarity on return values, required field interplay, or common invocation expectations, so the agent must rely heavily on schema inference.

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 43%, and the description adds no parameter meaning beyond the resource context. It does not mention required fields, optional associations, or the purpose of parameters like body, dealId, personId, or assigneeUserId.

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 a specific verb ('Create'), a distinct resource ('sales activity'), and the exact endpoint. This is enough to distinguish it from sibling tools like create-todo, create-note, and list-activities.

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 list-activities, update-activity, or other create-* tools. The endpoint and scope are useful, but the agent is left to infer 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. It does disclose a concrete behavior (POST request that creates a customer) and a required authorization scope (customers:write), which is useful. However, it does not describe the response shape, idempotency, validation failure behavior, or other side effects, so transparency is only 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 one concise sentence with no filler. It packs the endpoint information and scope requirement into a compact form, making it easy to scan. A bit more guidance would be desirable, but the structure itself is clean.

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 create operation with no annotations and no output schema, the description is minimal. It provides the endpoint and scope but lacks parameter semantics, usage guidance, and response expectations. An agent would need to look at sibling functions and trust the schema to correctly invoke this tool.

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

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

Schema description coverage is 0% and the description does not mention any parameter details. The input schema lists name, email, and phone with types and constraints, but the description adds no semantic guidance about these fields. Since coverage is low, the description was expected to compensate, and it does not.

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), resource (a customer), exact HTTP endpoint (POST /api/public/customers), and required scope (customers:write). This distinguishes it from sibling tools like get-customer, update-customer, archive-customer, and create-customer-contact.

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 when-not-to-use guidance is provided. While the name and verb make the core purpose obvious, there is no indication of how create-customer relates to alternative creation tools such as create-person, create-organization, or create-customer-contact, so the agent must infer the correct choice.

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

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

No annotations are provided, so the description carries the disclosure burden. It does reveal that the operation is a mutation (POST) and the required scope (customers:write), which is genuinely useful. However, it does not disclose the return value on success, error behavior, or whether creating a second isPrimary=true contact affects existing contacts.

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 dense sentence with zero fluff: purpose, endpoint, and scope in a single line, with the verb front-loaded. Every element 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 5 params, no annotations, no output schema, and only 20% parameter coverage, the description is too sparse: no return information, no note that customerId must reference an existing customer, and no parameter semantics. An agent can guess the basics but will be uncertain about outcome and edge 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 only 20% — customerId is the sole parameter with a description. The description adds no meaning for name, email, phone, or isPrimary, and the isPrimary semantics (e.g., what happens if another contact is already primary) are entirely unexplained.

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

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

States a specific verb+resource ('Create a contact on a customer') and reinforces it with the exact endpoint (POST /api/public/customers/{customerId}/contacts). The name and description clearly separate it from siblings like create-customer, list-customer-contacts, and update-contact.

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/when-not guidance and no mention of alternatives such as update-contact for existing contacts or list-customer-contacts for reading. Usage must be inferred from the name and the 'create' verb, and the prerequisite that the customer already exists is unstated.

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 does disclose the HTTP method (POST) and the required auth scope (sales:write), but it says nothing about side effects, failure modes, validation behavior, or what happens with unmentioned optional fields.

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, dense sentence that front-loads the core action, includes the endpoint, flags a required parameter, and states the permission scope. Every element earns its place with zero 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 tool with 9 parameters, no output schema, and no annotations, the description is too thin. It does not clarify field semantics (e.g., value units, currency), relationships between parameters, or what the API returns on success. More context is needed to call this reliably.

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 44%, so the description must compensate for undocumented parameters. It only restates that pipelineId is required (already in the schema) and adds no meaning for value, stageId, personId, lostReason, ownerUserId, organizationId, or expectedCloseDate.

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: 'Create a sales deal'. The HTTP endpoint is included for precision, and the name 'create-deal' clearly distinguishes it from update-deal, list-deals, and move-deal-stage among 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?

Usage is implied by the name and resource pairing: this is the tool to create a deal, as opposed to update-deal or list-deals. However, there is no explicit guidance on when to prefer this over alternatives, prerequisites like existing pipelines or owners, or 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 full burden. It does disclose the HTTP method and required auth scope, which is useful. But it does not mention side effects, validation behavior, idempotency, or what happens on success, so behavioral transparency is only 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?

A single concise sentence that front-loads the action, resource, endpoint, and required scope. There is no filler or redundant restating of the schema.

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 has 8 parameters, nested objects, 0% schema description coverage, and no output schema. The description only provides the endpoint and scope, leaving the agent without enough information to construct a correct create-form payload.

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 provides no parameter semantics at all. Fields like leadContract, allowedOrigins, and the canvas group are left entirely unexplained, so the agent gets no additional meaning beyond the bare property names and types.

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 ('Create') and a specific resource ('sales form'), and also gives the exact POST endpoint. This clearly distinguishes the tool from siblings like list-forms, get-form, and update-form.

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 creating a sales form, and the sibling names make the create-vs-update distinction obvious. However, it never explicitly states when to prefer this over update-form or what prerequisites apply beyond the sales:write scope.

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 transparency burden. It discloses the HTTP method and required scope (sales:write), which is useful, but it does not explain side effects, response behavior, or whether pinning/associating entities changes anything.

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 action, resource, endpoint, and required scope. There is no filler or duplication of schema details.

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

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

For a tool with no annotations and no output schema, this description is too sparse. It omits how parameters relate to each other, whether associations are required, and what the caller should expect after creation.

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 20%, so the description should compensate for undocumented parameters. It does not provide any additional meaning for dealId, pinned, personId, or organizationId, leaving relationships and constraints unexplained.

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: 'Create a sales note', and reinforces it with the exact POST endpoint. This clearly distinguishes it from siblings like get-note, update-note, and delete-note.

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 choose this tool over alternatives such as create-todo or create-activity. The endpoint and scope are stated, but there is no context about prerequisites, relationship to deals/people/organizations, or when list-notes/get-note should be used instead.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It does add useful context by specifying the HTTP method and required OAuth scope (sales:write), which implies a mutating operation. However, it does not disclose side effects, reversibility, validation failures, or response behavior.

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

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

The description is a single front-loaded sentence that includes the action, endpoint, and required scope. Every part earns its place, 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 three-parameter create operation, the endpoint and scope provide essential calling context. However, with no annotations and no output schema, the agent is left without any indication of the response shape, error cases, or side effects, so the description is adequate but not 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 only 33%, so the description needs to compensate for missing parameter context. It adds no information about the name, email, or phone parameters beyond what the schema already states. The schema defines the name field minimally and leaves email and phone largely undocumented in both schema and description.

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

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

The description states a specific verb and resource: 'Create a sales organization,' and includes the exact endpoint (POST /api/public/sales/organizations). This clearly differentiates it from sibling tools like update-organization, get-organization, and list-organizations.

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

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

The description implies use for creating a new sales organization, but it does not explicitly state when to prefer it over update-organization or list-organizations. The 'Scope: sales:write' line gives a useful precondition, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the HTTP method (POST), the resource path, and the required auth scope ('sales:write'), which is useful. However, it does not mention response behavior, whether the operation is reversible, or what happens on duplicate 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, front-loaded sentence that states the action, the resource, the endpoint, and the required scope. Every element earns its place 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 simple create operation with fully described input parameters, the description is largely complete: it identifies the resource, endpoint, and auth scope. The only notable gap is the absence of any return-value description, especially since no output schema is provided.

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 four parameters already have meaningful descriptions in the input schema. The tool description adds no param-level detail, but it does not need to because the schema 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 uses a specific verb ('Create') with a specific resource ('a sales person') and provides the exact POST endpoint. It is clearly distinct from sibling tools like update-person, get-person, and list-people.

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 establishes that this tool is for creating a sales person, which differentiates it from read/update/delete siblings without explicitly naming alternatives. It does not provide when-not-to-use guidance, but the context is strong enough for an agent to 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?

The description discloses that this is a write operation via POST and specifies the required stl:write scope, which is useful beyond the schema. However, with no annotations and no output schema, it does not describe side effects beyond creation, return value, or error behaviors.

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 that provides the action, resource, HTTP method, and required scope with no filler. Every clause adds useful 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?

Given five parameters, a nested object templateJson, three required fields, no output schema, and no annotations, the description is too sparse. It gives the endpoint and scope but leaves the agent unable to construct a valid request body without additional external knowledge.

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 provides no parameter-level explanation. The agent receives no guidance on what templateJson should contain, how customerIntegrationId is obtained, what receivingPhone format is expected, or how status behaves. The description fails to compensate for the missing schema descriptions.

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 action and resource — 'Create a Speed to Lead flow' — and expands the STL acronym. The POST /api/public/stl/flows endpoint marks this as the creation operation, distinguishing it from siblings like get-stl-flow, update-stl-flow, and list-stl-flows.

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 create verb and STL flow resource clearly imply this is for creating a new flow rather than updating or listing one, but no explicit alternatives or when-not-to-use guidance is provided. It relies on the agent to infer the boundary against 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 must carry the behavioral burden. It discloses the side effect (creation), HTTP method, and required scope (stl:write). It does not mention response shape, validation errors, or duplicate handling, but the core mutation behavior is clear.

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

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

The description is a single sentence that front-loads the core action and includes the endpoint and scope with no filler or redundant 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 two-parameter create operation with an explicit endpoint and scope, the description is nearly complete. It omits return value details and any uniqueness or validation expectations, but those are not critical given the simple schema and surrounding CRUD sibling tools.

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

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

The schema documents 'body' with a description but leaves 'name' undocumented, and the tool description adds no parameter-level detail. However, the parameter names are intuitive and the resource context ('STL SMS template') clarifies their meaning, so the description provides minimal added value without creating confusion.

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

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

The description states exactly what the tool does: 'Create an STL SMS template' with a specific endpoint. The create verb clearly differentiates it from sibling list/get/update/delete-stl-sms-template 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?

Usage is implied by the verb 'Create' and the resource name, but the description does not explicitly state when to use this tool versus alternatives, nor does it provide any exclusions or conditions. It is adequate but relies on 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?

No annotations are provided, so the description carries the disclosure burden. It adds useful context by stating the required auth scope ('todos:write') and the HTTP method/path, but it does not describe response shape, error behavior, or side effects beyond creation.

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: a single operational sentence plus a scope note. There is no repetitive or extraneous content, and the key information is front-loaded.

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

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

For a simple 3-parameter create operation, the endpoint and scope provide a workable foundation. However, the phrase 'PAT-bound team' is cryptic, and there is no guidance about expected response or preconditions, leaving some gaps for an agent to infer.

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 title, description, and isCompleted are already documented in the schema. The tool description adds no extra parameter-level meaning such as value formats, constraints, or dependencies.

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 ('Create a to-do') and names the exact endpoint (POST /api/public/teams/{teamId}/todos). The create verb clearly distinguishes this from sibling tools like list-todos, update-todo, and delete-todo.

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 explicit guidance about when to use this tool versus alternatives. The description only restates the create action and gives an endpoint/scope, but it does not mention when not to use it or how it relates to update-todo or other create 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 carries the full behavioral disclosure burden. It usefully discloses that the signing secret is returned only once and that the operation has a webhooks:write scope, but it omits other behavioral details like side effects, idempotency, or response structure beyond the secret.

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, front-loading the core action first. The endpoint, one-time secret warning, and scope are all conveyed in a compact structure where every clause 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 create operation with six parameters, nested objects, no output schema, and no annotations, the description is far too thin. It does not explain the full return value, required parameters, or post-creation behavior, leaving an agent under-equipped to invoke the tool correctly.

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

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

The input schema covers only 50% of parameters with descriptions; filters, isActive, and description are left unexplained. The tool description adds no parameter-level meaning, so an agent cannot determine how filters or isActive should be populated despite the nested object complexity.

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 webhook endpoint,' which is a specific verb plus resource and clearly distinguishes this tool from siblings like list-webhooks, get-webhook, update-webhook, and delete-webhook. It also adds the exact POST endpoint and required scope, reinforcing the tool's purpose.

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

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

There is no guidance on when to use this tool versus alternatives such as update-webhook or delete-webhook. The description does not state prerequisites, exclusions, or conditions that would help an agent decide between creating a new webhook and modifying an existing one.

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

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

The annotations already mark destructiveHint=true, and the description adds the sales:write scope and HTTP DELETE method. It does not specify permanence, cascade effects, or behavior when the note does not exist, but the annotation covers the core risk.

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, information-dense sentence that includes the action, endpoint, and required scope with no waste.

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 delete operation with a destructiveHint annotation and full schema coverage, the description is mostly complete. It could mention that deletion is permanent or note the response, but these are minor gaps 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 already fully documents the single 'id' parameter as 'Note id.' with 100% coverage, so the description adds no additional parameter meaning. Baseline 3 applies.

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

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

The description states a specific verb ('Delete'), resource ('sales note'), HTTP method, and required scope. This clearly distinguishes it from siblings like update-note, get-note, and create-note.

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: use this tool when you need to delete a sales note. However, it does not explicitly state when not to use it or mention alternatives such as update-note for modification or archive for non-destructive removal.

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 mark destructiveHint=true, and the description matches that by saying 'Delete'. It adds the required auth scope and HTTP endpoint, but does not describe additional behavioral details such as irreversibility or effects on dependent data.

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 action and pairs it with the endpoint and required scope. It contains no redundant 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 one-parameter deletion tool with destructiveHint already in annotations, the description is sufficient: it identifies the resource, endpoint, required id, and auth scope. It does not describe the response body, but no output schema exists and deletion responses are typically implied.

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

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

The schema covers 100% of the single parameter with a clear 'Flow id' description, so the baseline is 3. The endpoint path reinforces that id is the resource identifier but adds no new 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 states a specific action ('Delete') on a specific resource ('Speed to Lead flow') and includes the exact HTTP method and endpoint. This clearly distinguishes it from siblings such as get-stl-flow and update-stl-flow by the operation it performs.

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 scope requirement 'stl:write' gives useful context about when the call is permitted, and the delete verb implies when it should be used. However, it does not name alternatives or explicitly state when not to use deletion versus other flow operations.

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 flags the destructive nature. The description adds value by specifying the exact DELETE endpoint and the required stl:write scope, which gives the agent useful context about the operation's side effects and authorization needs. It does not mention error behavior, but the annotation covers the core safety warning.

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

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

The description is a single, tight sentence with the core action front-loaded followed by the endpoint and scope. Every piece of information is useful and nothing is repeated from the schema or annotations.

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

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

For a one-parameter destructive DELETE, the description combined with the schema and destructiveHint provides the necessary resource, method, id, auth scope, and safety signal. It does not describe response shape or edge cases, but an agent can confidently select and invoke the tool with what is provided.

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

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

Schema description coverage is 100%: the only parameter, id, is already fully described as a required positive integer lead id. The endpoint's {id} placeholder adds path-location context, but the description does not provide substantive additional 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 starts with 'Delete an STL lead', which is a clear verb+resource statement, and reinforces it with the explicit DELETE endpoint. This unambiguously distinguishes it from siblings like list-stl-leads and get-stl-lead.

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 choose this tool versus alternatives, when not to use it, or what conditions should be checked before deleting. The 'Scope: stl:write' line is an authorization requirement, not a selection criterion, and the usage context is only implied by the tool name.

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

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

The annotations already declare destructiveHint=true, so the destructive nature is covered. The description adds the HTTP method and the 'stl:write' scope, which is some useful authentication context, but it does not disclose consequences such as permanence, cascading effects, or behavior if the template does not exist.

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 action and includes the endpoint and required scope. Every part adds useful information without waste.

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 delete operation with destructiveHint already annotated, the description is largely sufficient with its endpoint and scope. It is missing only minor context such as the expected response or behavior on a nonexistent ID, but the tool's simplicity keeps these gaps from being significant.

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 only parameter 'id' is already documented as 'Template id'. The description adds no additional parameter semantics 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 states a specific verb and resource: 'Delete an STL SMS template', and further clarifies with the exact endpoint 'DELETE /api/public/stl/sms-templates/{id}'. This clearly distinguishes it from sibling tools like delete-todo, delete-stl-lead, and update-stl-sms-template.

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 alternatives. The scope 'stl:write' hints at authorization, but there is no mention of prerequisites, error conditions, or why this tool should be chosen over related STL template operations such as update-stl-sms-template or get-stl-sms-template.

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 communicates that this is a destructive operation. The description adds the HTTP method and auth scope but no extra behavioral detail such as irreversibility or effects on related data. Given the annotation coverage, this is adequate but not rich.

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

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

A single front-loaded sentence delivers the action, endpoint, and permission scope with zero filler. Every word contributes to the agent's ability to select and invoke the 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?

This is a low-complexity tool: one required parameter, no output schema, and a destructive annotation already present. The endpoint, scope, and schema are sufficient for correct invocation. Minor additions such as behavior for missing IDs would improve completeness but are not essential.

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 sole parameter 'id' is fully documented in the schema with type, bounds, and description. Schema coverage is 100%, so the description does not need to add parameter semantics. It adds no meaningful detail beyond the endpoint's {id}, but none is required.

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 ('Delete'), a resource ('to-do'), the REST endpoint, and the required scope. This clearly distinguishes delete-todo from sibling tools like update-todo or get-todo by both operation and resource.

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

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

The intended use is immediately obvious from the verb and resource, and the scope requirement ('todos:write') gives operational context. It does not explicitly contrast with alternatives, but for a simple delete operation this level of 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?

The destructiveHint annotation already flags this as destructive, and the description confirms what is destroyed (the webhook endpoint) and adds the HTTP method and required scope. It does not mention irreversibility or any side effects, but the annotation covers the main safety concern.

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 that front-loads the action and packs the useful endpoint and scope information without any filler. 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 destructive delete operation with no output schema, the description plus annotations is nearly sufficient. It could note the expected response or the irreversibility of the deletion, but these are minor omissions for a tool this simple.

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 type, bounds, and a description. The tool description adds nothing about parameters, but with 100% schema description coverage, 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 opens with the specific verb 'Delete' and the exact resource ('a webhook endpoint'), and also spells out the HTTP method and path. This makes it clearly distinguishable from sibling webhook tools like get-webhook, update-webhook, and list-webhooks.

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 verb and endpoint unambiguously indicate this tool is for removing a webhook rather than creating, reading, or updating one. The scope requirement 'webhooks:write' also gives the agent a clear authorization context, though no explicit alternatives or when-not-to-use conditions are stated.

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

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

Annotations already declare readOnlyHint=true. The description adds the exact endpoint and the required OAuth scope, enriching the behavioral profile. No mention of error behavior or response shape, but for a simple read operation this is acceptable.

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 action, then provides the endpoint and scope. No filler or redundant wording.

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, read-only fetch, the description is nearly complete. It includes endpoint and scope. The only minor gap is not explicitly stating the return representation, but the phrase 'Fetch a sales activity' adequately implies 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 100% for the id parameter, so the schema already documents it. The tool description adds no further parameter semantics beyond identifying the resource as a sales activity.

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 operation: 'Fetch a sales activity' with the specific endpoint and HTTP method. The singular resource and {id} path parameter distinguish it from list-activities or update-activity without 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 implies usage: retrieving a single activity by ID. It states the required scope 'sales:read' but does not explicitly contrast with list-activities or other alternatives, nor provide when-to-use/when-not-to-use guidance.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds the HTTP method and required OAuth scope (customers:read), enriching the behavioral context. For a simple fetch operation this is sufficient transparency.

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

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

The description is a single sentence that front-loads the operation, endpoint, and permission scope. There is no redundant or filler content; 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 simple get-by-id tool with one fully documented parameter, a readOnlyHint annotation, and no output schema, the description provides all essential context: what it fetches, how (GET), and what scope is required. Nothing critical 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 id parameter is already fully documented. The description only repeats the {id} placeholder from the endpoint without adding new semantic detail, matching the baseline for schema-covered parameters.

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

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

The description uses a specific verb ('Fetch') and resource ('a customer contact'), and the endpoint path clarifies exactly which object is retrieved. It distinguishes itself from siblings like list-customer-contacts (plural/list) and get-customer (different resource) without 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 clearly conveys this is for fetching a single customer contact by ID, with the HTTP method and scope. It does not explicitly name alternatives or when-not-to-use conditions, but the context is clear enough to route an agent correctly for a simple get-by-id operation.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds value by specifying the HTTP method (GET), the exact endpoint, and the required crm:read scope. It does not detail response shape or error behavior, but for a simple read-only fetch this is a minor omission.

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 compact and front-loaded: it leads with the action and resource, then provides endpoint and scope with no filler. 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?

With a single required id, a read-only annotation, and no nested objects, the endpoint/scope/resource information is sufficient for an agent to select and invoke the tool correctly. No critical prerequisites or additional context are 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% and the sole id parameter is already described as 'CRM lead id.' The description only reiterates the id in the URL template, adding no new semantic meaning beyond what the schema requires.

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 ('Fetch'), a specific resource ('a CRM lead'), and the exact endpoint, making the tool's purpose immediately clear. The singular resource and path distinguish it from list-crm-leads and approve/reject-crm-leads, even though those siblings are not named.

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

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

The intended use is implied: retrieve a single CRM lead by ID with read-only scope. However, the description never explicitly says when to use this over list-crm-leads, approve-crm-lead, or reject-crm-lead, and provides no exclusion 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?

The readOnlyHint annotation already covers the safety profile, and the description adds the crm:read scope. It does not disclose behavior such as 404 handling or response shape, but for a simple GET this is a minor gap given the annotation coverage.

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

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

The description is a single front-loaded sentence with the verb and resource first, followed by the endpoint and scope. There is no wasted text or redundant restatement of the schema.

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 with readOnly hint, the endpoint, id schema, and scope provide enough context to invoke the tool correctly. A note about missing submissions could add value, but it is not essential for a simple fetch.

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 id parameter is already described as 'Submission id.' The description does not add extra meaning beyond the endpoint path parameter, so it stays at the baseline.

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

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

The description explicitly states 'Fetch a CRM lead submission' with the exact HTTP endpoint, making the operation a single-resource GET. The resource term 'submission' distinguishes it from sibling get-crm-lead, and the scope is also specified.

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

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

The description provides clear retrieval context for a specific submission by id, but it does not explicitly say when to use this tool instead of list-crm-submissions or get-crm-lead. Usage is implied rather than explicitly contrasted with 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?

The readOnlyHint annotation already indicates a read operation. The description adds useful behavioral context by specifying the HTTP method (GET) and the required auth scope (customers:read), which helps an agent understand access requirements. It does not describe response format or error cases, but those are less critical given the annotation.

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

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

The description is one compact sentence that front-loads the action and resource, then adds endpoint and scope details. Every element earns its place with no redundancy.

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

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

For a single-parameter read tool with readOnlyHint and a clear endpoint, the description is nearly complete. It could additionally mention what the tool returns or how it handles not-found cases, but the absent output schema and simple signature make 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 input schema already documents the id parameter at 100% coverage. The description adds value beyond the schema by showing that id is a path parameter in the endpoint template, which clarifies how the parameter should be supplied.

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 ('Fetch'), a specific resource ('a customer'), and gives the exact endpoint pattern (GET /api/public/customers/{id}). This clearly distinguishes the tool from list-customers and other customer-related 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 singular 'a customer' plus the {id} path param implies this tool is for fetching one customer by ID, but it does not explicitly say when to prefer this over list-customers or how it differs from other get-* tools. Usage context is implied rather than stated.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds the exact endpoint and the OAuth scope 'sales:read', which is useful, but it does not disclose error behavior, response shape, or any other behavioral traits. No contradiction with annotations.

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

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

The description is a single sentence that is entirely functional, front-loaded with the verb and resource, and contains no redundant words or filler.

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

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

For a simple single-parameter read-only fetch with a readOnlyHint annotation, the description and schema together give enough information for an agent to select and invoke the tool. Missing return-value details are not critical for invocation, though a bit more context about error responses would make it 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% with the id field described as 'Deal id.' The description adds no additional meaning for the id parameter beyond what the schema already 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 uses the specific verb 'Fetch' with the resource 'a sales deal' and includes the full HTTP endpoint. This distinguishes it clearly from list-deals and other get-* sibling tools so an agent can immediately understand the operation.

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

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

The description makes it clear this tool fetches a single deal, and the required id parameter strongly implies it is for when a known deal id is available. However, it does not explicitly mention when not to use it or name alternatives like list-deals, leaving some room for 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?

Annotations already declare readOnlyHint=true, and the description adds the REST method/path and the sales:read scope, which is useful context beyond the annotation. However, it does not disclose what 'default' resolves to, possible empty/error behavior, or response shape; there is no contradiction.

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

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

A single sentence contains the action, resource, endpoint, and scope with no filler. Everything 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 read-only fetch, the description is nearly complete: it states what is fetched, the endpoint, and the required scope. The only gaps are explicit differentiation from sibling pipeline tools and a note about return shape, both minor at this complexity 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 tool has zero parameters, so the input schema fully covers semantics and there is nothing for the description to add. Baseline for zero parameters is 4, and the description includes endpoint/scope context that supports correct invocation.

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 ('Fetch') and resource ('team default sales pipeline'), and includes the exact endpoint and auth scope. This distinguishes it from siblings like get-pipeline and list-pipelines without requiring the agent to open 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?

No explicit guidance is given for when to use this tool versus list-pipelines or get-pipeline, and no alternatives are named. The phrase 'team default' implies the intended use case, but the description leaves the choice 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?

Annotations already mark readOnlyHint true; the description adds meaningful behavioral context by specifying the HTTP method, exact endpoint, and required OAuth scope 'sales:read'. This extra detail helps the agent understand access requirements and operational safety without repeating annotations.

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

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

Two sentences, no filler. The endpoint, scope, and resource are all stated efficiently and front-loaded. Every part 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 read-only GET with no output schema, the description provides the necessary operational details: what it fetches, how to call it, and the required scope. No critical information appears 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?

The schema covers the single 'id' parameter fully. The description adds value by making clear that 'id' is a path parameter via the endpoint template, which the schema does not explicitly state.

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 ('Fetch'), a clear resource ('a sales form'), and an exact endpoint with path parameter. This clearly distinguishes get-form from sibling tools like list-forms and get-form-submission.

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 singular resource and {id} path make it clear this is for retrieving one specific form by ID. It does not explicitly name alternatives or exclusions, but the usage context is readily inferred.

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

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

The readOnlyHint annotation already signals a read operation, and the description adds useful context: the HTTP method GET and the required scope sales:read. This is meaningful auth-scope transparency beyond the annotation, though error behavior is not described.

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 states the action, resource, endpoint, and scope with no filler. Every part earns its place, and the core purpose is front-loaded.

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

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

For a simple one-parameter read-only tool, the description plus schema is sufficient for an agent to invoke it correctly. The return value is only implied by 'Fetch a sales form submission', and there is no explicit note about not-found or auth-failure behavior, but those are minor gaps.

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

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

The input schema already fully documents the single id parameter with 100% coverage, including its type, bounds, and description 'Submission id.' The tool description adds no additional parameter semantics, 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 uses a specific verb, 'Fetch', names the exact resource, 'sales form submission', and gives the endpoint pattern with an {id} placeholder. This clearly distinguishes the tool from its sibling list-form-submissions and from get-form.

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 endpoint and 'Fetch a ... {id}' make it clear this tool retrieves a single submission by ID. It provides clear context for when to call it, though it does not explicitly name list-form-submissions as the alternative for fetching multiple submissions.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds valuable behavioral context beyond that: it explicitly guarantees secrets are not included in the response and names the required 'integrations:read' scope. This helps an agent set expectations about both output content and authorization.

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 a single, information-dense sentence that front-loads the primary behavior ('List connected integrations'), then adds the essential caveat ('without secrets'), the endpoint, and the required scope. 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 operation, the description covers the key facts an agent needs: what it lists, what it excludes, the endpoint, and the required permission. The absence of a response format description is a minor gap, but not critical for such a straightforward operation.

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

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

There are zero parameters and the schema has full coverage, so the baseline of 4 applies. The description correctly does not introduce phantom parameters and provides enough context for a parameterless call.

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 action and resource: 'List connected integrations'. It also specifies the key constraint 'without secrets' and the exact HTTP endpoint, making the tool's purpose unmistakable even among many list-* 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 clearly indicates this is the tool to use for listing connected integrations, reinforced by the API path and required scope. It does not explicitly discuss when not to use it, but no alternative integration-listing tool exists among siblings, so the context 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?

The readOnlyHint annotation already establishes the operation is non-destructive, and the description adds useful behavioral context by enumerating what the call returns and signaling that it is an initial discovery call. It does not cover error behavior or authentication failure, but for a simple zero-parameter GET this is adequate.

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

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

Two concise sentences, with the most actionable information front-loaded: what the endpoint returns, the HTTP verb, and the recommended invocation order. There is no redundancy or filler.

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

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

Given the tool has no parameters, no output schema, and a simple read-only purpose, the description fully covers what an agent needs: the endpoint, the returned data categories, and when to call it. 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?

The tool has zero parameters, so there are no parameter semantics for the description to clarify. The baseline of 4 applies here; describing return values instead of parameters is appropriate for a parameterless discovery endpoint.

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 precise verb and resource: it returns the signed-in user, PAT-bound team, enabled modules, and token scopes via GET /api/public/me. This clearly distinguishes it from sibling tools like list-teams or get-team, which operate on team collections rather than the caller's own context.

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 to call this first to learn team id and available modules, providing clear situational guidance. It does not explicitly name exclusions or compare alternatives, but the 'call this first' instruction is strong enough context for an agent to prioritize 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?

Annotations already declare readOnlyHint=true; the description adds value by confirming the HTTP method, endpoint pattern, and required scope, reinforcing that this is a safe 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?

A single sentence packs the action, endpoint, and auth scope with zero filler; every element 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-only fetch with readOnlyHint=true and no output schema, this is fully sufficient for an agent to call 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?

The schema description covers the single id parameter 100%, and the description adds no extra semantic detail about the id beyond 'team member'. 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 names a specific verb ('Fetch'), a concrete resource ('team member'), and the exact endpoint with scope. This clearly distinguishes it from list-members and get-me without requiring schema inspection.

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 GET-by-id pattern and 'members:read' scope imply the tool is for retrieving a single member, but the description does not explicitly state when not to use it or name sibling alternatives such as list-members.

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

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

Annotations already declare readOnlyHint=true, and the description corroborates with 'Fetch' and 'GET'. It adds useful behavioral context beyond annotations by specifying the required sales:read scope and the exact REST endpoint, which helps an agent understand authorization needs.

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

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

The description is a single efficient sentence that front-loads the action and resource, then adds the endpoint and scope. No filler or redundant content.

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

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

For a simple read-only fetch with one well-documented parameter, the description, schema, and annotations provide enough information to invoke the tool correctly. It does not describe the return shape, but the resource name and endpoint strongly imply the response, and no output schema exists to expect richer documentation.

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

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

The schema already fully documents the single id parameter with type, bounds, and description, so the description adds no additional semantic meaning. Baseline of 3 is appropriate because schema coverage is 100%.

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 starts with a specific verb and resource ('Fetch a sales note') and reinforces it with the exact endpoint and scope. This clearly distinguishes it from list-notes and other get-sibling 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 tool's purpose and required id imply it is for retrieving one note when its id is known, but it does not explicitly say when to use it over list-notes or other alternatives. No when-not-to-use guidance is provided.

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

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

Annotations already mark readOnlyHint=true, and the description adds the HTTP method GET and the required auth scope 'sales:read'. This gives useful operational context beyond the annotation without contradicting it.

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 states the action, resource, endpoint, and auth scope with no filler. Every element 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 fetch with one fully documented parameter and a clear endpoint, the definition is sufficient for correct selection and invocation. It does not describe the response shape, but no output schema exists and 'Fetch' implies the organization is returned.

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 already described as 'Organization id.' The description adds no extra parameter detail, 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 names the exact verb ('Fetch'), resource ('sales organization'), and HTTP endpoint including {id}. This clearly distinguishes it from list-organizations and other get-* 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 singular resource and path parameter make the use case clear: retrieve one organization by id. It does not explicitly mention list-organizations as the alternative, but the context is unambiguous 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?

Annotations already declare readOnlyHint=true, and the description adds the GET method and 'sales:read' scope, which is useful context. It does not go deeper into response behavior, pagination, or error handling, but for a read-only single-resource fetch this is adequate.

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

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

The description is a single, dense sentence that includes the action, endpoint, and required scope. Every word adds value and the core purpose is front-loaded.

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

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

For a one-parameter read-only fetch, the description provides enough information to invoke the tool correctly: endpoint, scope, and resource type. It does not describe the response shape, but given the simple nature and readOnlyHint, this is a minor gap rather than a critical omission.

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

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

The schema provides 100% coverage for the single 'id' parameter with a clear 'Person id.' description. The description adds only the endpoint placeholder context, which is helpful but not a major addition beyond the schema.

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

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

The description clearly states the action ('Fetch a sales person') and the exact resource via the endpoint path. It is distinct from list-style siblings like list-people, though it does not explicitly differentiate itself by 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?

The endpoint and required id implicitly signal that this tool is for retrieving a single sales person by ID. However, there is no explicit guidance on when to choose this over alternatives like list-people or get-me, and no exclusions or prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint=true, so the description is not burdened with proving safety. It adds useful context by specifying the exact endpoint and the required sales:read scope, which helps the agent understand access requirements.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the operation, the resource, the endpoint, and the required scope 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?

This is a simple single-parameter read operation, and the schema plus annotations cover most of what the agent needs. The description adds endpoint and scope, and notes that stages are included; a full return-shape description is not 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 coverage is 100% and the 'id' parameter is already documented as 'Pipeline id.' The description does not add any additional meaning or format details for the parameter 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 names a specific verb ('Fetch'), a specific resource ('a sales pipeline'), and a distinguishing detail ('with stages'). The endpoint and scope provide enough detail to separate it from list-pipelines and get-default-pipeline.

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 core use case clear: fetch one pipeline by id. However, it does not explicitly say when to prefer this over list-pipelines or get-default-pipeline, leaving differentiation 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?

Annotations already mark readOnlyHint=true; the description adds useful behavioral context by naming the HTTP method/path ('GET /api/public/settings') and clarifying that only non-secret settings are returned. This goes beyond the annotation without contradicting it.

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, information-dense fragments with no filler. Endpoint, scope, and the non-secret caveat are all 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 zero-parameter, read-only public settings endpoint, the description covers what it returns (non-secret team settings), how to call it (GET path), and required scope. Return shape is not detailed, but the simplicity of the tool keeps this from being a major gap.

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

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

The tool has zero parameters and schema coverage is 100%, so the baseline of 4 applies. The description correctly needs no parameter details because there are none to document.

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 ('Fetch') and resource ('non-secret team settings'), plus the exact endpoint and OAuth scope. This clearly identifies the tool and distinguishes it from sibling tools like get-integrations or get-default-pipeline.

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 'non-secret team settings' plus 'Scope: settings:read' gives clear context on when this read-only settings endpoint is appropriate. It does not name exclusions or alternatives, but no sibling settings tool exists, so this 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?

Annotations already establish readOnlyHint=true, and the description adds the specific HTTP GET method and required stl:read scope without contradicting the annotations. It does not mention error responses or return shape, but for a simple read-only fetch the disclosed endpoint and scope are 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 entire description is one compact sentence that front-loads the action and resource, then appends the endpoint and scope. There is no filler or redundancy; every element earns its place.

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

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

For a single-parameter, read-only GET operation with no output schema, the description is largely complete: it gives the endpoint, scope, and resource. The only minor gap is that it does not describe the expected response shape or not-found behavior, but the simple fetch semantics make this a marginal omission.

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

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

Schema description coverage is 100%: the id parameter is fully documented with type, bounds, and required status. The description adds no parameter-level detail, but the baseline 3 applies because the schema already carries the full semantic burden.

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

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

The description names a specific verb ('Fetch'), a specific resource ('Speed to Lead flow'), and the exact GET endpoint with an {id} parameter. This clearly distinguishes it from list-stl-flows, update-stl-flow, and delete-stl-flow, and leaves 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?

The description implies this tool retrieves a single known flow by id, but it does not explicitly state when to prefer it over list-stl-flows or when to use alternatives like update-stl-flow/delete-stl-flow. The endpoint and scope provide context, but no direct usage guidance is 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?

Annotations already declare readOnlyHint=true, and the description aligns by using 'Fetch' and showing the GET verb, so there is no contradiction. The description adds the scope requirement ('stl:read') but does not disclose other behaviors such as error responses or the shape of the returned lead, which is acceptable given the read-only annotation lowers the burden.

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 purpose ('Fetch an STL lead') is front-loaded, followed by the endpoint and scope. Every part 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 read-only fetch tool, the description is complete: it names the resource, the exact endpoint, the required scope, and the operation type. With readOnlyHint provided and no output schema, nothing essential is missing for an agent 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?

The input schema covers the only parameter completely (id, with 'Lead id.' and constraints). The description adds no additional meaning beyond what the schema already provides, so the baseline 3 applies.

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

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

The description states a specific verb ('Fetch') and resource ('an STL lead'), and includes the underlying REST endpoint (GET /api/public/stl/leads/{id}), which makes the operation unambiguous. It distinguishes itself from sibling list-stl-leads by implying a singular fetch by id, though it does not 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?

Usage context is implied: an agent would use this when it needs a specific STL lead by its id rather than a list of leads. However, there is no explicit when-to-use or exclusion guidance, and no alternative tool is named, so the agent must infer the distinction from sibling 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?

The readOnlyHint annotation already declares the operation safe and non-mutating. The description adds the auth scope 'stl:read' and the HTTP method, which is useful, but it does not mention error cases, response shape, or rate limits. This is adequate for a simple read fetch but not rich 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 focused sentence that states the action, the resource, the endpoint, and the required scope. Every element earns its place, and the most important information is front-loaded.

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

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

For a one-parameter read-only fetch with a readOnlyHint annotation and clear sibling differentiation, the description is nearly complete. It could mention what the response contains, but for a GET-by-id resource this is usually inferable, and the existing scope and endpoint details cover the essential context.

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

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

The schema fully documents the only parameter 'id' as 'Template id.' with proper constraints. The description does not add any meaning beyond the schema, so the baseline score applies.

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

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

The description has a specific verb ('Fetch'), a specific resource ('STL SMS template'), and an explicit REST endpoint. It clearly distinguishes a single-entity fetch from the sibling list operation 'list-stl-sms-templates'.

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

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

The context is clear: use this tool when you have a template id and need a single STL SMS template. It does not explicitly name alternatives or state when not to use it, but the read-by-id semantics and sibling list tool make the intended usage obvious.

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

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

The annotations already declare readOnlyHint=true, which establishes the tool as non-mutating. The description reinforces this with the GET endpoint, but it does not disclose behavior on edge cases like invalid or non-existent ids. Given the read-only annotation, the description adds acceptable but minimal behavioral context.

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

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

The description is a single, focused sentence that immediately states the verb and resource. Including the endpoint is useful and does not add unnecessary length.

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 read-only fetch, the description provides enough context: the resource, the endpoint, and the required id. However, without an output schema, a note about the return shape or missing-team behavior 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?

The input schema fully documents the id parameter with type, constraints, and description, so schema coverage is 100%. The description adds no parameter semantics beyond what the schema already provides.

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

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

The description clearly states the operation: 'Fetch a team by id' and includes the HTTP endpoint. This distinguishes it from sibling tools like list-teams, which fetch multiple teams, and get-me, which fetches the current user.

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 should be used when a specific team id is known and a single team is needed. It does not explicitly mention alternatives such as list-teams for enumeration, nor does it provide when-not-to-use guidance.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation, so the description is not required to restate safety. It adds the HTTP method GET and endpoint path, which is mildly useful, but it does not disclose behaviors such as 404 responses, authentication needs, or what happens when the tenant does not exist.

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

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

The description is a single sentence that immediately states the action, resource, and endpoint. It contains no filler or redundant information and is optimally front-loaded.

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

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

For a simple one-parameter, read-only fetch operation, the description is largely complete. The lack of an output schema is somewhat compensated by the tool name and the description's clear endpoint, though return format and error behavior 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%: the id parameter has a clear description, type, and bounds. The tool description only repeats 'by id', which adds no new semantic detail 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 uses a specific verb and resource: 'Fetch a tenant by id' and includes the exact HTTP endpoint GET /api/public/tenants/{id}. This clearly distinguishes it from sibling list tools like list-tenants by indicating it retrieves a single tenant by identifier.

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 explicit guidance on when to use this tool versus alternatives. It does not mention that list-tenants should be used for multiple tenants, nor does it state any prerequisites or exclusions. Usage context is only implied by the phrase 'by 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?

The annotations already declare readOnlyHint=true, so the safe read-only nature is covered. The description adds the HTTP method and the OAuth scope 'todos:read', which is useful authentication context beyond the structured annotation. However, it does not mention error behavior (e.g., 404 for missing to-do) or response format, so the added behavioral context is modest.

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

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

The description is a single, information-dense sentence with no filler. It front-loads the core action, then packs the endpoint and scope into parentheses. Every element earns its place, making it easy to parse 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 get-by-id tool with one parameter and a read-only annotation, the description covers the key invocation details: the endpoint, the scope, and the operation. The only notable gap is that it does not describe the return value shape or error behavior, but since there is no output schema and the tool's purpose is highly idiomatic, this is a minor omission. Overall, an agent has enough to call 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?

The schema description coverage is 100%, and the id parameter already has a clear description ('To-do id.'). The tool description only says 'by id', which adds no meaningful semantic detail beyond what the schema provides. This 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 clearly states the action ('Fetch a to-do by id') and the resource, making it unambiguous. It also includes the HTTP method and path, and the required scope, which further pins down the operation. This distinguishes it from sibling tools like list-todos without needing to open 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 'by id' implies it is for retrieving a single to-do when you have its identifier, which implicitly contrasts with list-todos. However, there is no explicit guidance about when to choose this tool over alternatives, nor any mention of when not to use it. The usage context is inferred rather than stated.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful behavioral context by specifying the HTTP method (GET) and the required OAuth scope (webhooks:read), which helps the agent assess authorization requirements. No contradiction exists.

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 conveys the action, resource, HTTP method, and scope with no filler. Every element 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 read operation, the description is nearly complete: it includes the endpoint, scope, and intent. It could be strengthened by noting that the agent should use this tool when it needs a specific webhook by id, but the schema and annotations cover the remaining operational essentials.

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 only parameter 'id' is already described as 'Webhook id.' The description adds little beyond showing that the id is used in the URL path, which does not substantially change the agent's understanding of the parameter.

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

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

The description clearly states a specific verb ('Fetch') and resource ('a webhook endpoint'), along with the exact HTTP path. This distinguishes it from sibling tools like list-webhooks, create-webhook, update-webhook, and delete-webhook without needing to inspect 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 description gives clear context that this tool fetches a single webhook endpoint, but it does not explicitly state when to use it versus list-webhooks or mention any exclusions. Usage is implied by the singular resource and id parameter, not explicitly contrasted with 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 carries the burden. It discloses the HTTP method (POST), indicating a write operation, and the required scope (members:write). However, it does not mention side effects such as whether an invitation email is sent, whether an existing member causes an error, 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?

One dense, front-loaded sentence that conveys the action, endpoint, and required permission. There is 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 two-parameter write operation, the description covers purpose and authentication scope. However, with no annotations and no output schema, important operational details—like duplicate handling, invitation workflow, and expected response—are absent, leaving a noticeable gap for agent decision-making.

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

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

Schema coverage is 100%, with both parameters documented as 'Team role name' and 'Invitee email'. The description adds no additional parameter semantics 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?

States a specific action ('Invite a member by email') and the exact resource and HTTP endpoint (POST /api/public/members). It is clearly distinct from siblings like list-members, get-member, and change-member-role.

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

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

The description implies this is for adding a new member, but it does not explicitly say when to use it versus change-member-role for role adjustments or list-members/get-member for reading. No alternatives are named, so usage context must be inferred from the verb 'invite'.

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

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

The readOnlyHint annotation already covers the safety profile, and the description adds the endpoint and sales:read scope. However, it does not disclose other behavioral details such as pagination behavior, ordering, or what subset of sales activities is returned.

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

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

The description is two short sentences with no filler: it front-loads the action and resource, then gives endpoint and scope. Every token 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 endpoint with fully documented optional pagination parameters, the description plus schema is largely sufficient. Adding a note about the response being a paginated list would improve completeness but is not necessary for correct invocation.

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 (q, page, itemsPerPage) have descriptions in the input schema, so the schema covers 100% of parameter meaning. The tool description adds no parameter-specific details, keeping this at the baseline for full schema coverage.

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

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

The description names a concrete action and resource—'List sales activities'—and reinforces it with the exact endpoint and OAuth scope. This clearly separates it from sibling tools like get-activity, create-activity, and update-activity.

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 GET verb and read-only scope imply this is the tool for listing sales activities, but the description does not explicitly state when to choose it over get-activity or other list_* siblings. The intended use is inferable but not explicitly contrasted with 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?

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds the GET method and crm:read scope, which are mild supplements, but it does not disclose pagination behavior, response shape, or how the q parameter affects 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 compact sentence with no filler. The core action is front-loaded, followed by the endpoint and scope, making it 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?

The tool is simple and read-only, with all parameters documented, but the description lacks important invocation context such as pagination defaults, result format, and how to distinguish this from list-stl-leads. It is adequate but leaves clear gaps.

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

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

All three parameters are already described in the schema with 100% coverage, so the description carries no additional parameter-level meaning. This matches the baseline for schema-covered parameters.

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

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

The description opens with a specific verb and resource, 'List CRM leads', and is reinforced by the explicit endpoint path and required auth scope. This clearly differentiates it from sibling tools like get-crm-lead by indicating a collection operation rather than a single-resource fetch.

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 prefer this tool over alternatives such as get-crm-lead or list-stl-leads. It states what the tool does but not the conditions or context that should drive tool selection.

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

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

The readOnlyHint annotation already signals non-destructive behavior, and the description adds the required crm:read scope, which is useful auth context. However, it does not disclose return shape, pagination behavior, or any other operational caveats, so the added behavioral context is limited.

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 wasted words. It states the operation, resource, endpoint, and required scope 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?

The schema and annotations cover basic call mechanics, and the endpoint/scope cover access. However, with no output schema and no explanation of what a 'CRM submission' is or how it differs from related tools like list-crm-leads and get-crm-submission, the description leaves important selection and interpretation context to inference.

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 parameter descriptions for q, page, and itemsPerPage already provide the necessary meaning. The tool description itself adds no parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('CRM lead submissions'), and adds the HTTP endpoint, so the agent knows exactly what operation is exposed. It is clear but does not explicitly distinguish this tool from siblings like list-crm-leads or list-form-submissions.

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 the required scope and endpoint but gives no guidance on when to choose this tool versus alternatives such as get-crm-submission, list-crm-leads, or list-form-submissions. An agent must infer usage from the tool name and endpoint.

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

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

Beyond the readOnlyHint annotation, the description adds the HTTP method (GET) and required authorization scope (customers:read), giving the agent concrete expectations about side effects and permissions. It does not contradict the annotations.

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

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

A single sentence contains the action, resource path, and scope with no filler or repetition. Every element 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 read-only list operation, the combination of description, full parameter schema, and readOnlyHint covers what an agent needs to select and invoke the tool. Pagination is expressed through page/itemsPerPage in the schema, and no output schema is expected for this simple list 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 input schema already documents all four parameters with descriptions (100% coverage). The description adds the endpoint template, clarifying that customerId is a path parameter, but does not need to repeat parameter details. This meets the baseline for high schema coverage.

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

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

The description identifies the exact action (List contacts), the resource scope (for a customer), and the endpoint path. It clearly differentiates this from sibling tools like list-customers and get-contact by specifying the customer-scoped contact collection.

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 contacts belonging to a specific customer, as reflected by the customerId path parameter. It does not explicitly name alternative tools for single-contact retrieval or creation, but no exclusions are needed because the purpose is 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?

Annotations already declare readOnlyHint=true, and the description reinforces this with the HTTP method GET. It adds the required 'customers:read' scope, which is an auth-relevant behavioral detail not present in the annotations.

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

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

A single compact sentence communicates the operation, endpoint, and scope with zero filler. All information is immediately relevant 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?

This is a low-complexity list operation: annotations cover the read-only behavior, the schema covers all parameters, and the description supplies endpoint and auth scope. Pagination defaults are already declared in the schema, so nothing critical 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 for the three parameters is 100%, so the schema already documents q, page, and itemsPerPage. The description adds no extra semantics or format details beyond that baseline 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 specific verb ('List') and resource ('customers'), and pins it to the exact endpoint (GET /api/public/customers). This clearly differentiates it from sibling tools like list-customer-contacts and list-crm-leads, whose resources are distinct.

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 choose this tool over alternatives such as list-customer-contacts or list-crm-leads. The description only states the endpoint and scope, leaving usage context entirely to inference.

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

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

The annotation readOnlyHint=true already declares read-only. The description adds the HTTP method (GET), required OAuth scope (sales:read), and optional pipelineId filter, which go beyond annotations. It does not mention pagination or response format, but the schema covers pagination parameters.

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

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

Three short sentences front-load the core action and then provide endpoint, filter, and scope. No redundant or vague wording; every sentence adds value.

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

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

For a simple read-only list tool, the description is adequate but not complete: it omits the response shape and default behavior when no filter is provided. There is no output schema to compensate, and the description does not specify whether the result is a paginated array or summaries. However, the pagination parameters in the schema provide some context.

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

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

Schema coverage is 100% and each parameter has a clear description. The tool description only repeats the pipelineId filter, adding no new semantic information. Thus baseline 3 is appropriate 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?

States a specific verb and resource: 'List sales deals.' It also includes the HTTP endpoint and optional filter, making its function unambiguous. The tool name itself signals list vs. get, so it is clearly distinguished from get-deal.

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 explicit guidance about when to use this tool over alternatives like get-deal; it only states the action and scope. The optional pipelineId filter and sales:read scope are prerequisites, but no direct comparison to sibling tools is provided. Usage is implied only by the tool name and the endpoint.

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 readOnlyHint=true, so the safety profile is covered. The description adds the HTTP method (GET) and required scope (sales:read), which is useful context, but does not detail pagination behavior or response shape beyond what the schema implies.

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, compact sentence that includes the key information: what the tool does, the endpoint, and the required scope. There is no redundant or filler content.

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

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

For a straightforward read-only list operation, the description plus schema and annotations provide enough context. It does not explain the return format, but no output schema is provided and the tool's purpose is simple enough that this is not a critical 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?

All three parameters (q, page, itemsPerPage) are fully described in the input schema, so the description does not need to add much. It adds no parameter-specific detail beyond the schema, which is acceptable at the baseline for high schema coverage.

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

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

States a specific verb and resource: 'List sales forms', and also includes the exact endpoint. This clearly distinguishes it from siblings like create-form, update-form, get-form, and list-form-submissions.

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 use case clear: listing sales forms. It does not explicitly name alternatives or exclusions, but the sibling list and the endpoint make the intended context obvious 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?

The readOnlyHint annotation already indicates a safe read operation. The description adds the HTTP method and scope, which is useful context, but it does not disclose behavior like pagination semantics, search scope, or response shape.

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 action, resource, endpoint, and required scope with no wasted words.

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

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

The description is adequate for a simple read-only list operation, and schemas document the parameters well. However, it lacks guidance on what 'sales form submissions' specifically includes versus related tools, and there is no mention of the response format.

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 100% of the parameters, so the baseline is 3. The description itself adds no extra parameter-level meaning beyond what the schema already provides.

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

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

The description clearly states the verb ('List'), the resource ('sales form submissions'), and the exact endpoint. It is distinct from siblings like list-forms and get-form-submission, though it does not explicitly contrast 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 usage context is implied by the verb 'List' and the resource name, but there is no explicit guidance on when to choose this tool over alternatives such as list-crm-submissions or get-form-submission.

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

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

The readOnlyHint annotation already establishes that this tool does not mutate state. The description adds a small amount of context with the endpoint and OAuth scope, but it discloses no further behavioral traits such as what members are included, how results are ordered, or whether the response is paginated. There is no contradiction with the annotations.

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

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

The description is extremely concise and front-loaded: it states the action first, then provides the endpoint and scope in a compact format. Every element is informative and there is no redundant or filler wording.

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 readOnly annotation and fully documented parameters, the description is largely complete. It includes the endpoint and required scope, which helps the agent understand context. The main gap is the absence of any information about the return shape, but that is partially mitigated by the simplicity of a list operation 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?

All three parameters (q, page, itemsPerPage) are already fully described in the input schema, so the description does not need to re-explain them. It also adds no additional semantic detail at the parameter level, so a baseline 3 is appropriate due to the 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 and resource: 'List team members', and reinforces it with the HTTP endpoint and required scope. It is unambiguous, though it does not explicitly differentiate itself from sibling tools like get-member or list-people beyond the plural 'members' in the tool name and description.

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

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

The description provides no direct guidance on when to use this tool versus alternatives such as get-member, invite-member, or change-member-role. The 'members:read' scope is useful context, but it does not explain selection criteria or when a different member-related 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?

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds the sales:read scope requirement and the exact GET endpoint, which are useful details, but it does not disclose other behaviors such as pagination defaults or response structure. The annotations cover the primary safety 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 extremely concise, covering resource, HTTP method, endpoint, and required scope in a single sentence with no filler. Every element 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 three optional parameters and no output schema, the description together with the schema and annotation is nearly complete. It provides the endpoint and permission scope; only a brief mention of return format or pagination behavior could push it higher, but it is not 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?

All three parameters (q, page, itemsPerPage) are fully described in the input schema with defaults and bounds. The description adds no extra parameter meaning, but it does not need to because schema coverage is 100%.

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'), the resource ('sales notes'), and includes the REST endpoint and required scope. It unmistakably distinguishes this tool from get-note, create-note, update-note, and delete-note among the sibling 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 this tool—whenever a list of sales notes is needed—but it does not explicitly contrast it with related note tools like get-note or create-note. Usage context is clear from the verb and resource, but no when-not guidance is provided.

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

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

The description adds the HTTP method (GET) and the required auth scope (sales:read), which supplements the readOnlyHint annotation with actionable context. It does not address rate limits or response shape, but those are less critical for a read-only list operation with documented pagination parameters.

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 action, endpoint, and scope with no filler. Every element 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 listing tool, the endpoint, scope, and schema-documented parameters provide a workable baseline. However, with no output schema, the response format is left implicit, and there is no guidance about edge cases or when to prefer sibling tools.

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

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

The input schema already describes all three parameters (q, page, itemsPerPage) with 100% coverage, so the description contributes no additional parameter semantics. A baseline of 3 is appropriate when 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 'List sales organizations' and provides the exact endpoint, making the verb and resource unambiguous. It is distinguishable from get/update/create-organization by the 'List' verb, though it does not explicitly contrast with other list-* sibling 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 gives no guidance on when to use this tool versus alternatives such as get-organization or list-customers. There is no mention of use cases, exclusions, or conditions, so an agent must infer usage solely from the tool name.

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

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

Annotations already provide readOnlyHint=true, and the 'List' verb is consistent with that. The description adds the endpoint (GET /api/public/sales/people) and scope (sales:read), which go beyond the annotations. However, it does not disclose pagination defaults, ordering, or response envelope behavior, so it adds modest but not rich 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?

Two compact segments—'List sales people/contacts' plus endpoint and scope—with zero filler. The primary verb and resource are front-loaded and every word contributes 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, required-parameter-free list tool with 100% schema coverage and readOnly annotations, the description covers the essential extra context: the exact API endpoint and the required scope. The main gap is that the result format and pagination behavior are left implicit, but that is acceptable for a straightforward list tool with 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 coverage is 100%, so all three parameters (q, page, itemsPerPage) are already documented with descriptions and defaults in the schema. The description adds no parameter-level detail beyond implying what 'q' would search against ('sales people/contacts'). Baseline 3 is appropriate given 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: 'List sales people/contacts', and adds concrete context with the HTTP endpoint and required scope. It is clearly a read operation on a distinct resource. However, with many sibling list tools (list-members, list-customers, list-crm-leads), it does not explicitly differentiate when this tool is the right one for sales people vs those others.

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. The description gives no when/when-not conditions and names no sibling tools, so an agent must infer from the name alone that this is the choice for sales people rather than customers, members, or CRM leads.

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

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

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds the required scope 'sales:read', which is useful auth context, but it does not disclose pagination behavior, response shape, or any other operational quirks beyond the schema.

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

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

The description is a single concise sentence that front-loads the action and resource, then adds the endpoint and scope. There is no redundant or filler language.

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 optional pagination parameters and a readOnly annotation, the description is largely complete. It could benefit from a brief note distinguishing it from get-pipeline, but the core calling context is sufficiently clear.

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 q, page, and itemsPerPage with their defaults and constraints. The description adds nothing about parameter semantics beyond what the schema provides, matching 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 ('List') with a clear resource ('sales pipelines') and includes the HTTP endpoint for precision. It is clearly distinguishable from sibling tools like get-pipeline and get-default-pipeline, which are single-item or specialized lookups.

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 such as get-pipeline or get-default-pipeline. The listing semantics are implied by the verb 'List', 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?

Annotations already declare readOnlyHint=true, so the description need not re-establish read-only behavior. It does add the HTTP method and the required stl:read scope, but it does not describe pagination behavior, response format, or edge cases.

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, front-loaded with the action and resource, followed by endpoint and scope. No unnecessary words or repetition.

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

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

For a simple list operation, readOnlyHint covers safety and the schema covers all optional parameters. The description gives endpoint and scope, but without an output schema a brief note that it returns a list of STL flows would make it fully self-contained.

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

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

All three parameters already have schema descriptions, so the schema provides full parameter coverage. The tool description adds no additional meaning beyond what the schema already states, so baseline 3 applies.

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

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

Description starts with 'List Speed to Lead flows', a specific verb and resource. The endpoint and 'Scope: stl:read' further clarify the operation, and the plural 'flows' clearly distinguishes it from get-stl-flow and mutation 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 gives no guidance on when to use this tool versus get-stl-flow, create-stl-flow, update-stl-flow, or delete-stl-flow. 'Scope: stl:read' indicates permission requirements but not usage context or exclusions.

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

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

The readOnlyHint annotation already signals that this is a read operation. The description adds the GET method and the stl:read scope, which provide some useful context about auth requirements, but it does not disclose any additional behavioral traits such as response shape, pagination behavior, or filtering semantics beyond what the schema already covers.

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

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

The description is a single sentence that front-loads the verb and resource, then provides the endpoint and scope with no filler. Every word earns its place, and it 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 endpoint with fully documented optional parameters, read-only annotation, and no nested objects, the description plus schema is largely sufficient. It could be slightly more complete by explicitly noting that this returns a paginated list, but the page/itemsPerPage parameters already imply that.

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

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

Schema description coverage is 100%, so the schema already documents q, page, and itemsPerPage with meanings and defaults. The description adds no further parameter-specific information, 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 a specific resource ('Speed to Lead leads'), and includes the exact endpoint and required scope. This clearly distinguishes it from singular sibling tools like get-stl-lead and from list-crm-leads by naming the Speed to Lead domain.

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 a collection-listing use case through the word 'List' and the GET endpoint, but it does not explicitly state when to choose this over sibling tools like get-stl-lead or delete-stl-lead. No exclusions or alternative routing guidance is provided.

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