Chasync

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the description adds value by clarifying that the operation is a soft delete that preserves historical email data. This nuance is not present in the annotations and helps the agent understand the exact behavioral effect beyond simple mutation.

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 states the action, the resource, and the key nuance in a compact way, earning its place without redundancy.

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

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

For a simple tool with one parameter and an output schema, the description covers the essential purpose and the soft-delete behavior. It does not mention permissions or what happens to the archived template, but these are likely covered by the output schema and the tool's simplicity. The description is sufficient for an agent to decide and invoke it correctly.

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

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

Schema description coverage is 100%, meaning the schema already fully documents the _id parameter as 'Chasync email template ID to archive.' The description adds no additional meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action (archive) and the resource (email template), and it adds the crucial qualifier 'without permanently deleting historical email data' to distinguish it from a hard delete. It also differentiates from sibling tools like archive_form and archive_funnel by targeting email templates specifically.

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

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

The description implies the tool is for removing a template from active use while preserving history, but it does not explicitly state when to use this over save_email_template or when not to use it. It also does not mention any prerequisites or fallback scenarios. The usage context is only implied through the phrasing about not permanently deleting.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true; the description adds the key behavioral fact that archiving means flipping an 'inactive' flag rather than deleting the form. This is useful context beyond the structured metadata, though it doesn't mention reversibility or secondary effects.

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

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

One short, front-loaded sentence with no filler; every word earns its place. It states the action, resource, and result efficiently.

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

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

For a single-parameter mutation with an output schema, rich annotations, and sibling context, the description is nearly complete. It could add whether archiving is reversible or how it affects list_forms, but those are minor gaps given the structured metadata already present.

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

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

Schema coverage is 100%, so the schema already fully documents the _id parameter as 'Chasync form ID to archive.' The description adds no parameter-level detail 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 states a specific verb ('Archive'), a clear resource ('a form'), and the mechanism ('setting it inactive'), which makes the operation unambiguous. It also differentiates the tool from its siblings by naming the exact resource and action.

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

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

No guidance is provided about when to use this tool instead of get_form, save_form, or list_forms, nor any exclusions or preconditions. The only implicit signal is the tool name and sibling 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?

The description adds value beyond the annotations by revealing that archiving is implemented by 'setting it inactive,' implying a soft-delete behavior. This clarifies that the action is reversible at some level, which complements the idempotentHint and destructiveHint annotations without contradicting them.

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

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

The description is a single, compact sentence that front-loads the action and resource ('Archive a funnel') and then explains the mechanism. Every word contributes, with no redundancy or unnecessary detail.

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

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

For a simple tool with one well-documented parameter, an output schema, and annotations covering safety and idempotency, the description covers the essential specifics. It could mention reversibility or permission requirements, but the annotations and schema already provide adequate 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 input schema already provides a complete description of the sole parameter ('Chasync funnel ID to archive') with 100% coverage. The tool description adds no further parameter detail, so the baseline score of 3 applies.

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

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

The description states a specific action on a specific resource: 'Archive a funnel' and adds the mechanism 'by setting it inactive,' which clearly distinguishes it from sibling tools like archive_email_template and archive_form. It 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 usage by naming the resource ('funnel') but does not explicitly contrast against alternatives or state conditions like 'use this when you want to deactivate a funnel rather than delete it.' Since the purpose is clear from the name and resource, there is minimal but adequate guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description does not contradict them. However, it adds no behavioral context beyond 'existing bulk logic'; it doesn't say whether updates replace fields, how conditional params interact, or what side effects occur.

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

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

The description is only one sentence and avoids filler, but the phrase 'using Chasync's existing bulk logic' is vague and doesn't add useful structure. It is concise at the cost of informative 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?

Despite a rich schema and output schema, the tool has 10 params with conditional dependencies and destructive semantics; the description does not explain overall behavior, update semantics, or when to select this tool. An agent would need the schema plus external context to use it correctly.

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

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

Schema description coverage is 100%, and each parameter explains its role and 'used when update_type is...' conditions. The description itself adds no parameter meaning, so the baseline 3 is appropriate.

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

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

The description states the verb 'Update' and resource 'selected leads' with 'bulk' signaling batch scope compared to sibling save_lead. It does not enumerate which update types are supported, but the title and schema fill that in.

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

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

No guidance on when to use this tool instead of save_lead or import_leads; there is no mention of prerequisites, limits, or exclusion cases. The plural 'leads' and name imply bulk use, but that is inference rather than instruction.

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 a safe, idempotent, closed-world read, so the description's job is to add context beyond that. "Non-secret" is a genuine scope/security disclosure that tells the agent no credentials or sensitive values are returned, which is information annotations do not carry.

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

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

A single front-loaded sentence with no filler or boilerplate. Minor redundancy in using "settings" twice ("account settings ... and settings useful when..."), which slightly muddies the sentence's rhythm but costs no comprehension.

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

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

An output schema exists, so return values need not be explained in prose, and with no parameters there is no input contract to document. The description covers the content scope adequately; only the relationship to get_account_statistics is left implicit.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no schema-driven parameter meaning the description needs to compensate for. The description correctly frames the tool as a context fetch requiring no input.

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?

Specific verb ("Get") plus a well-defined resource ("account settings, plan capabilities"), and it enumerates the content categories returned. It implicitly separates itself from get_account_statistics (settings vs. metrics) but never names it, so sibling differentiation is left to inference rather than stated.

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

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

The phrase "useful when creating funnels, forms, emails and leads" hints at when an agent would reach for this tool, which is real but implied guidance. There are no explicit exclusions, prerequisites, or named alternatives among the many sibling list/get tools, so the when-not condition 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description need not repeat those. It adds value by listing the metrics included and the default month behavior. No contradiction with annotations; the description is consistent with a read-only, idempotent operation.

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

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

The description is a single, information-dense sentence that front-loads the action and resource, then lists metrics efficiently. It contains no filler or redundant phrasing, making it highly concise while still being complete.

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

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

Given the presence of an output schema and annotations covering safety and idempotency, the description provides sufficient context: it states what is included, defaults, and scope. Nothing critical is missing for an agent to invoke the tool correctly, though it could mention that both year and month default to current values (but the schema already does 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 coverage is 100%, and both parameters (year, month) are fully described in the schema with their defaults. The description only repeats the month default and adds no new parameter semantics beyond what the schema already provides, so it meets the baseline but does not exceed it.

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

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

The description states a specific verb ('Get') and resource ('monthly Chasync performance statistics'), and enumerates the exact metrics included (leads, emails sent, opens, etc.), making it unambiguous. There are no sibling tools for statistics, so it naturally distinguishes itself.

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

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

The description provides clear context that the tool returns monthly statistics and defaults to the current month, which implicitly tells the agent when to call it (when account performance data is needed). There are no alternative statistics tools, so no explicit exclusions are required, but it lacks an explicit 'when not to use' statement.

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 communicate read-only, idempotent, non-destructive behavior. The description adds minimal behavioral context beyond 'reusable', but it does not contradict the annotations. Since the safety profile is fully covered by annotations, a baseline score of 3 is appropriate.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaningful information about the resource and scope.

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

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

Given the tool's low complexity, a single required parameter, the presence of an output schema, and annotations that fully define side effects, the description is complete enough for correct invocation. 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 schema fully documents the only parameter, '_id', with 100% coverage. The description does not add any parameter-level detail beyond what the schema already provides, so the schema carries the semantic weight.

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

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

The description states a specific verb ('Get'), resource ('email template'), and singular scope ('one'), which distinguishes it from the sibling list_email_templates. It does not explicitly name alternative siblings, but the singular framing gives enough clarity for an agent to identify 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?

Usage is implied: retrieve a single email template by ID rather than listing templates or creating/archiving them. However, the description gives no explicit when-to-use or when-not-to-use guidance and does not name alternatives such as list_email_templates or save_email_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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the return-content detail about fields and funnel assignment but no further behavioral context. This matches the baseline with strong 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?

One concise sentence that front-loads the action and resource, with no filler or redundant information. Every word contributes to the meaning.

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

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

The tool is simple: one required parameter, a documented output schema, and annotations covering safety. The description fully supports correct selection and invocation without missing 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 only parameter, _id, is already fully described in the schema as 'Chasync form ID' with 100% coverage. The description adds no additional parameter-level meaning beyond what the schema provides.

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

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

The description states a specific verb ('Get'), a clear resource ('one lead capture form'), and the content scope ('including fields and funnel assignment'). This distinguishes it from list_forms 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?

No guidance is given about when to use this tool versus alternatives like list_forms or get_funnel. The use case must be inferred from the single-ID parameter and the word '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?

Annotations already cover safety with readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context about what the returned funnel contains, but it does not disclose additional behavior like error handling, permissions, or response structure. This is acceptable 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, efficient sentence with no filler. The key qualifier 'complete' is front-loaded, followed by a concise enumeration of the returned components, making it easy to scan and act on.

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, single-parameter getter with an output schema and full annotations, the description is nearly complete. It could explicitly point users to list_funnels when a summary is sufficient, but nothing critical is missing for invoking the tool correctly.

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

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

Schema coverage is 100% and the only parameter, _id, is already described as 'Chasync funnel ID.' The description adds no further parameter-level meaning, but the schema fully documents the single required input, 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?

States a specific verb and resource ('get a complete funnel') and names the content — steps, email variants, waits, and routing rules — which clearly distinguishes it from sibling tools like list_funnels or save_funnel. The qualifier 'complete' communicates that this returns the full object, not a summary.

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

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

The description implies when to use it: when a complete funnel object is needed. However, it does not explicitly mention alternatives such as list_funnels for lighter listing use cases or state when not to use this tool. The guidance is left to inference from the word 'complete' and the sibling list.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the single-result behavioral nuance, but does not mention behavior when no lead is found or when both _id and email are supplied.

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, tightly written sentence with no filler. The most important detail, the lookup mechanisms, is front-loaded and immediately actionable.

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-fetch tool with rich annotations, full schema descriptions, and an output schema, the description is sufficient. An agent knows what the tool does, what inputs to provide, and that it is a safe read operation.

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

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

Schema description coverage is 100%, with both _id and email already documented. The description restates the lookup keys at a high level, but adds no extra semantic detail 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 uses a specific verb ('Get'), a specific resource ('one lead'), and explicit lookup keys ('Chasync _id or exact email address'). It clearly distinguishes this single-record retrieval tool from siblings like list_leads and save_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?

The description clearly conveys the intended use case: fetching exactly one lead by a known identifier or exact email. It does not explicitly name alternatives or exclusion conditions, but the lookup criteria are specific enough to route an agent 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds minimal behavioral context beyond reiterating the read nature and the authentication scope. It does not contradict annotations and provides a small extra detail about the connection, but nothing substantial.

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

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

The description is a single, concise sentence with no filler. It front-loads the action and resource, and the qualifier 'represented by the current authenticated connection' adds precision without bloat.

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

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

For a simple read-only tool with no parameters and an output schema (which likely defines the profile structure), the description is fully sufficient. It states what is returned (the profile) and the context (current authenticated connection), leaving no gaps 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?

There are zero parameters, so the description does not need to explain any. The baseline for 0 parameters is 4, and the description appropriately avoids unnecessary parameter information, leaving the schema to handle any future additions.

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

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

The description uses a clear verb 'Get' and specifies the resource 'Chasync user profile', further narrowing it to 'the current authenticated connection'. It is distinct from sibling tools which target other entities like forms, funnels, or leads, so an agent can easily identify this as the profile retrieval tool.

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

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

While it does not explicitly state when to use it vs alternatives, the tool is the only one dealing with the user profile, and its purpose is self-evident. The description implies its usage context (retrieving the connected user's profile) without ambiguity, though it could be more explicit about 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?

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the risk profile is largely covered. The description adds real behavioral value beyond that: it gates the call on an account capability and warns against emulating bulk import via save_lead loops. It does not describe partial-failure behavior across a 500-lead batch, which would be the remaining useful addition.

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

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

Three short sentences, front-loaded with the action, followed by the precondition and the anti-pattern warning. No filler or restatement of the title.

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

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

With an output schema present, return values need no explanation, and the annotations plus the capability gate cover the safety and eligibility picture. The only gap is what happens to a partially valid batch, which is a minor omission for an otherwise complete definition.

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% across both parameters, including the meaning of skip_existing, so the schema does the heavy lifting. The description adds no parameter-level detail (e.g., behavior when skip_existing is false or how duplicates are matched), so the baseline 3 applies.

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

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

States a specific verb and resource with explicit scope ('multiple leads'), which separates it from the single-lead save_lead sibling. An agent can tell what operation is being performed without opening the schema.

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

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

Gives an explicit, checkable precondition (get_account_context.capabilities.bulk_lead_import must be true) and an explicit prohibition against the wrong workaround (repeatedly calling save_lead). This is textbook when/when-not guidance with a named alternative.

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

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

Annotations already disclose that the operation is read-only, idempotent, and non-destructive, so the description does not need to repeat those traits. It adds limited behavioral context by noting the templates are 'reusable' and scoped to funnels, but it does not disclose ordering, pagination behavior, or default filtering beyond what the schema offers.

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

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

The description is a single, front-loaded sentence with no redundant words or filler. It conveys the essential purpose and 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?

For a simple list tool with no required parameters, fully described parameters, comprehensive annotations, and an output schema, the description is complete enough for an agent to invoke it correctly. The funnel scope is the main additional context needed, and it is present.

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

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

Schema description coverage is 100%, with all three parameters (limit, active, locale) fully documented. The description adds no parameter-level meaning, but because the schema already provides complete semantics, the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('email templates'), and adds scope ('for funnels'), which clearly distinguishes it from single-item tools like get_email_template and mutation tools like save_email_template or archive_email_template. The title 'List Chasync email templates' reinforces the purpose.

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

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

The description does not explicitly state when to use this tool versus alternatives such as get_email_template for a single template or save_email_template for creating one. Usage is only implied by the verb 'List' and the sibling tool names, with no exclusions or conditions 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 cover readOnly, idempotent, and non-destructive behavior, and the description adds the useful scope of 'connected Chasync account' and the 'lead capture' nature of the forms. It does not disclose pagination, defaults for archived/inactive forms, or ordering, but this is a simple list with an output schema and non-conflicting 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, front-loaded sentence that conveys the action, object, and scope without filler. Every word earns its place, and there is no repetition of the title beyond what is necessary for precision.

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 tool with one optional parameter, full schema coverage, and an output schema, the description is largely sufficient. It is only missing light context such as the active-filter option or a pointer to get_form for single-form details, neither of which is critical given the structured fields.

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 parameters are documented in the schema; the single optional 'active' parameter already has a clear description ('Filter forms by active status'). The tool description adds no additional parameter meaning, so the baseline of 3 for high schema coverage 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 ('lead capture forms'), and scopes it to the connected Chasync account, making the operation clear. It does not explicitly contrast with siblings such as get_form or archive_form, but the list/get/save/archive verbs inherently distinguish it enough to be clear.

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

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

No guidance is given about when to select this tool over list_funnels, list_email_templates, get_form, or archive_form. The description only states what it does, leaving the agent to infer the appropriate 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds only the 'connected Chasync account' context, but no additional behavioral details such as default sorting, pagination behavior, or response envelope. 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 says exactly what the tool does without redundancy. Every word contributes value, and nothing is missing at the summary level.

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 simple listing operation, fully documented optional parameters, a present output schema, and comprehensive safety annotations, the description is sufficient for an agent to invoke this tool correctly. No critical operational gap remains.

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 each parameter (limit, active, locale) already documented in the input schema. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description uses the specific verb 'List' with a clear resource, 'sales funnels', and scopes it to 'the connected Chasync account'. This distinguishes it from sibling tools like list_forms and list_leads, and from get_funnel, which implies a single-item 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 implies usage: when you need a list of funnels. However, it provides no explicit guidance about when to prefer this over get_funnel or other list tools, nor does it mention any exclusion criteria or alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description needn't repeat safety. It adds the behavioral trait that the tool returns 'exact account and filtered lead totals,' which is not in the annotations or schema, providing additional context about the output.

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, front-loaded with the core purpose ('List leads using common filters') and immediately adds the distinctive return value ('exact account and filtered lead totals'). 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?

Given the tool's complexity (6 optional filter parameters, 1 enum), the schema covers all parameters, annotations cover safety, and an output schema exists (not shown but mentioned). The description clearly states what it does and what it returns, 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?

The schema has 100% description coverage for all 6 parameters, so the description does not need to add parameter details. However, the description's mention of 'using common filters' implies the filtering parameters, but adds no extra meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'List leads using common filters and return exact account and filtered lead totals.' It identifies the resource (leads) and the action (list), and distinguishes it from siblings by emphasizing the 'exact account and filtered lead totals' return, which is unique among list tools.

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

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

The description implies when to use this tool (when you need to list leads with filters and get totals) but does not explicitly exclude alternatives like get_lead or list_funnels. However, given the sibling list, the distinction is clear enough for an agent to infer the right 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?

Beyond the annotations (readOnlyHint false, destructiveHint true), the description adds the non-obvious behavior that Chasync automatically appends the connected user's signature and instructs the agent not to include one in email_body. No contradiction exists between the description and 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 two sentences, with the action front-loaded and no filler. It includes the single most important usage caveat and earns every word.

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

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

With full schema coverage, a rich input schema, output schema, and annotations available, the only additional context needed is the auto-signature behavior, which is present. Agents have everything needed to call the tool correctly.

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

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

Schema description coverage is 100%, so all 9 parameters are already documented in the input schema. The description's signature warning repeats what the email_body parameter already says, adding no new parameter-level 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 opens with 'Create or update' and names the specific resource, 'reusable Chasync email template,' which clearly defines the operation and resource. This distinguishes it from sibling tools like get_email_template, list_email_templates, and archive_email_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?

The description gives clear context for when to use the tool: to create or update a Chasync email template, which naturally separates it from read and archive siblings. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutation risk is known. The description adds the assignment side effect but does not disclose what an update overwrites, whether omitted fields are cleared, or how clear_description/remove_funnel_assignment interact with the update. It is consistent with annotations but adds limited behavioral context beyond them.

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

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

The description is a single sentence with no filler, front-loading the core operation, the resource, and the optional behavior. Every phrase earns its place.

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

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

The rich input schema and output schema cover parameter meaning and return value shape, and annotations cover the destructive nature. However, for a create-or-update tool with 11 parameters and zero required fields, the description could clarify update semantics (what is replaced vs preserved) and the effect of the clear_description and remove_funnel_assignment flags, rather than leaving that entirely to schema property descriptions.

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

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

Schema description coverage is 100%, so each parameter is already documented in the input schema. The description mentions funnel and step assignment, which maps to assign_to_funnel and assign_to_funnel_step, but it does not add meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses specific verbs ('create or update') and names a concrete resource ('Chasync lead capture form'), then adds a distinguishing behavior: optionally assigning submissions to a funnel and step. This is enough to separate it from sibling save_email_template, save_funnel, and save_lead 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 phrase 'create or update' clearly implies two usage modes: omit _id to create, provide _id to update, and the optional funnel/step assignment states a likely reason to call the tool. However, there is no explicit when-to-use vs alternatives or exclusions, so the guidance 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds real value by disclosing the merge behavior: steps are preserved unless remove_step_ids names them, clarifying that the tool is not destructive by default despite the destructive annotation. It could go further (e.g., how top-level fields like title or sender merge on update), but the preservation disclosure is meaningful beyond 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?

Two sentences with zero filler. The core create/update purpose and component list are front-loaded in the first sentence, and the critical preservation behavior occupies the second. Every clause earns its place, with the highest-risk semantic detail placed last.

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 complex tool (12 params, deep nesting, output schema present), the description is minimal but the schema carries the heavy lifting at 100% coverage and the output schema explains returns. The essential agent-facing knowledge — create vs. update and the non-destructive-by-default step semantics — is present. A small gap remains around merge behavior for top-level fields, but this is largely covered by the rich schema and annotations.

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 12 parameters are documented in the schema and the baseline is 3. The description adds marginal meaning by mapping 'steps, emails, waits and routing rules' to the steps structure and explicitly tying remove_step_ids to the preservation rule, but it does not explain 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 uses a specific verb pair ('Create or update') with a clear resource ('Chasync funnel') and enumerates the managed components (steps, emails, waits, routing rules). It plainly distinguishes itself from siblings like archive_funnel, get_funnel, and list_funnels by establishing this is the create/update entry point, so an agent can pick it without opening the schema.

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

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

The description implies usage context (creating or updating a funnel) and adds one key semantic rule — 'Existing steps are preserved unless remove_step_ids explicitly names them' — which is genuinely useful for deciding how to invoke it. However, it never explicitly contrasts with alternatives (e.g., use save_email_template for standalone templates, get_funnel to read) and gives no when-not-to-use guidance, leaving routing 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=true), it discloses that omitting _id with an existing email mutates the existing lead, which is useful. However, it does not say whether missing fields are cleared or overwritten, what happens when _id is provided but not found, or whether email is required for creation. The destructiveHint annotation covers the safety signal, but the concrete mutation semantics remain ambiguous.

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 create/update action is front-loaded, and the conditional is direct.

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 23 optional parameters and an output schema, the description can be lean, but it leaves unresolved edge cases: creating without an email, updating by a nonexistent _id, and whether updates merge or replace fields. The upsert branch is the most important context and is present, yet an agent still has to infer several behaviors. It 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?

The schema already documents 100% of parameters, so the baseline is 3. The description adds the crucial relationship between _id and email—omitting _id while an email exists triggers an update—which the per-property schema descriptions do not connect. This elevates parameter understanding, though it does not explain create-only prerequisites.

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 opening phrase 'Create or update a Chasync lead' names a precise action and resource, and the singular 'a lead' separates it from bulk or import siblings. The second sentence adds the key upsert branch. It is clear and not tautological.

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

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

It states what the tool does but never tells an agent when to prefer it over sibling tools such as bulk_update_leads or import_leads. The condition around _id and email is internal upsert behavior, not an exclusion or alternative. Usage context is only implied by the title and description.

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