KaiCalls

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

Annotations already provide a strong behavioral profile: readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds no additional behavioral context beyond saying 'Check', which is consistent with the annotations. It doesn't disclose potential quirks like whether the response is cached or live, but the annotation coverage 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 a single, front-loaded sentence with zero wasted words. It states the verb, the target resource, and the parameter in one pass, making it easy to scan and understand.

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 low-complexity tool with one parameter, strong annotations, and an output schema, the description covers the essential selection and invocation context. It doesn't mention how to obtain a valid call_id or enumerate possible statuses, but those are secondary given the output schema and simple purpose.

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 schema already explains call_id as 'The call ID to check'. The description's 'by its ID' adds no quantitative or formatting 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 states a specific verb ('Check'), a clear resource ('status of a call'), and the key discriminator ('by its ID'). This differentiates the tool from siblings like list_recent_calls, get_call_recording, and get_phone_system_status without requiring the agent to infer intent.

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 its ID' provides clear context for when to use this tool: when the agent has a specific call_id and needs that call's status. It doesn't explicitly name alternative tools or exclusions, but for a simple single-resource lookup the usage context is reasonably clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false. The description goes beyond that by explaining it 'cannot assert or advance proof' and clarifying that a completed private test is separate from customer-route coverage and that forwarding is optional. That added context is valuable, though return shape is left to the output schema.

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

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

Information is front-loaded with the primary purpose in the first sentence, but the paragraph is dense and some sentences (the forwarding/customer-route distinction) are hard to parse and could be tightened.

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 complete schema coverage, full annotations, and an output schema, the description covers the key behavioral caveats an agent needs—eligibility, non-advancement of proof, and the optional nature of forwarding. Sufficient, with minor room to clarify return values.

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

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

Schema description coverage is 100%, so all five parameters are already documented (including business_id optionality and session rejection). The description adds no per-parameter meaning beyond that; 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 (read) and resource (current call readiness and persisted private-test proof) scoped to one business. It is clearly a read/status tool distinguishable from setup siblings like set_up_phone_system or get_setup_checklist, though it doesn't name an explicit alternative.

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

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

Provides clear context on what qualifies (entitled owner with coherent assigned number, completed private test) and what does not (missing entitlement, incomplete setup, stale sessions). No explicit when-to-use-this-vs-sibling routing, but the eligibility conditions are strong 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 annotations already carry the safety profile (readOnlyHint=true, idempotent, non-destructive), so the description only needs to add behavior beyond that. It adds the time-window concept and the dashboard-summary scope, but nothing extra about rate limits, caching, or data freshness—acceptable when annotations already cover safety.

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 tightly worded sentence front-loads the action and resource, then enumerates the included metrics in a clear parenthetical. There is zero filler or 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?

An output schema is present, and the description succinctly states what the tool returns (a dashboard summary with listed metrics) and exposes the time-window semantics. Combined with the schema's param and returned structure, nothing needed for correct invocation 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%, with the single parameter 'days' fully documented (min, max, default). The description's phrase 'recent time window' merely reinforces the schema without adding new constraints or behavioral rules, 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?

The description states a specific verb and resource: 'Get a dashboard summary' and enumerates the exact metrics (lead counts, conversion rate, call volume, top agents, business outcomes). This distinguishes it from sibling tools like get_usage or list_recent_calls, which have different scopes and data shapes.

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

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

It gives clear context: use when you want a high-level dashboard summary over a recent window. Though it doesn't explicitly exclude alternatives or name a sibling tool, the context is specific enough for an agent to select it over single-call or detailed-report 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?

Annotations already cover read-only, idempotent, non-destructive, and closed-world behavior, so the bar is lower. The description adds genuine context beyond that: it discloses that the output carries a next_step pointer naming the next tool to call, which is useful routing behavior not captured 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?

Three sentences, front-loaded with what is returned before the usage condition. Every sentence carries weight, though the middle clause is slightly more verbose than necessary.

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-required-parameter getter with an output schema and full annotation coverage, the description is complete enough: it covers purpose, entry condition, and the next_step routing signal. Nothing essential to correct invocation is missing.

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

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

Schema coverage is 100% and the single business_id parameter is fully documented in the schema. The description adds no syntax or format detail beyond what the schema 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 states a clear verb+resource ('Read back what a business already has') and enumerates the returned content: profile details, agent count, and recent call volume. It is unambiguous, though it does not explicitly differentiate itself from adjacent getters like get_usage or get_analytics.

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

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

It gives a concrete entry condition ('Start here when someone wants a business number that answers missed calls') and explains the intent of avoiding duplicate creation. It also names the follow-up behavior via next_step when no working phone line exists, giving clear context without explicit 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds that the tool returns a 'real call recording URL' rather than audio content itself, which is useful context. It does not mention URL expiration, access restrictions, or whether the recording is always available, but annotations cover the safety profile.

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

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

A single, focused sentence that explains both what the tool does and why it matters. No filler, front-loaded with the key purpose.

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

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

For a simple one-parameter read-only lookup with an output schema and clear annotations, the description is sufficient. It could mention URL expiration or auth requirements, but those are not critical for selection or 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?

Schema coverage is 100%, and the single parameter call_id is already fully described in the schema. The description adds no additional meaning about the parameter beyond its existence, so it meets the baseline without providing extra value.

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

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

The description clearly states the action ('Get'), the resource ('call recording URL'), and the purpose ('so reviewers can listen to the voice/audio'). It also differentiates from get_transcript by emphasizing audio over transcript.

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 reviewers need the actual voice/audio rather than the transcript, which differentiates it from the sibling get_transcript. However, it does not explicitly state when not to use it or name the alternative directly, so it falls just short of full 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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description goes beyond annotations by explaining the data lineage (where the audit entries come from, including the phone tool) and stating that the changes are reversible through rollback_config, which implies a non-destructive read view. This adds meaningful behavioral context without contradicting 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 compact at two sentences, begins with the core result details, and packs the source, the covered mutations, the relationship to the voice tool, and the rollback capability into one dense block. No filler or redundancy. Each sentence earns its place.

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

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

Given the output schema exists, the description does not need to replicate return formats. It successfully covers the purpose, data fields, source store, provenance, possible callers, and even a related rollback sibling. Nothing critical for correct invocation is missing: an agent would know what it reads, why it exists, and how to use it in 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%; both agent_id and limit are fully described in the input schema. The description does not add extra semantics for the parameters themselves, only reasserts 'recent' and 'limit' indirectly via 'recent' in the first sentence. Since the schema carries the full parameter burden, 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 opens by stating the specific resource ('agent's recent config-change audit trail') and enumerates the exact fields returned (change_type, change_source, old/new value, timestamp). It places the tool at admin_change_history and connects it to the same record read by the admin_get_change_history voice tool, so the purpose is unambiguous even before looking at 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 clearly indicates this tool is appropriate for inspecting config-change history and explicitly explains that every mutation made through named tools (update_agent_config, configure_agent_business_rules, the admin call-in secretary, the dashboard) is logged here. It also notes that these changes are reversible with rollback_config, which gives the agent a reason to invoke this tool. It does not explicitly exclude alternatives such as list_config_versions, but the context is strong enough for correct 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds minor context about return content but does not disclose additional behavioral details such as not-found behavior or freshness of the score.

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 is fully informative, front-loaded with the action and resource, and contains no filler or repetition.

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

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

For a simple single-ID read operation with a full output schema and safety annotations, the description is complete. Nothing an agent needs to call this tool correctly is missing.

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

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

Schema description coverage is 100%, so the parameter is already documented as 'The lead ID to fetch'. The description adds no new parameter-level meaning beyond reinforcing that the fetch is by ID.

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

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

The description states a specific verb ('Get') and a specific resource ('full details for a single lead by ID'), and distinguishes it from list_leads by indicating this is for one lead. The mention of the latest AI lead score and explanation adds useful specificity.

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

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

The description clearly implies usage when a lead_id is known and full detail is needed, and the singular wording contrasts with list_leads for bulk retrieval. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to choose correctly.

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

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

Annotations already establish readOnly/idempotent/non-destructive, and the description adds genuine behavioral context beyond them: a 30-minute source lag, the access prerequisite, and precise definitions for 'connected phone calls' (>30s duration) and 'responsiveness' (previous 90 days). These metric definitions materially affect interpretation of the result.

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?

Front-loaded with the purpose, followed by access, date semantics, freshness, and metric definitions in a tight sequence. Every sentence carries information, though the density of the metric-definition clause is slightly harder 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?

An output schema exists, so return values need not be described. For a read-only aggregate report, the description covers purpose, access requirements, date bounds, freshness, and metric definitions adequately; only the identity parameters remain unexplained.

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

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

Schema description coverage is 0%, so the description carries the burden, and it partially delivers: 'Dates are calendar dates inclusive at both ends' clarifies start_date/end_date semantics. However, business_id and connection_id receive no explanation at all, leaving half the parameters 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?

States a specific verb and resource ('Read the authorized advertiser's live Google Local Services aggregate account report') and names what it is not (signed-case revenue or lead-rating reporting), which routes away from rate_lsa_lead. It does not, however, explicitly distinguish itself from the sibling get_lsa_report, leaving some ambiguity between the two report 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?

Provides a prerequisite ('Requires linked manager-account access') and a negative disambiguation ('not signed-case revenue or lead-rating reporting'), which is useful context. It stops short of stating when to choose this over get_lsa_report or get_lsa_conversations, so selection guidance remains implied rather than explicit.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the safety profile needs no restating. The description adds genuinely useful context beyond that: a hard 200-event cap and a staleness caveat telling the agent results only reflect previously synced data unless sync_lsa is run.

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 sentences that front-load what is returned (latest 200 synced events) before the prerequisite caveat. No redundant restatement of the tool name or title, and every clause adds 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?

An output schema exists, so return structure need not be described. The description covers scope limit, content, and the sync dependency; the only meaningful gap is the undocumented business_id, which is a schema-side deficiency rather than a description 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 0% and neither parameter is documented in the schema, so the description must carry the burden. It only weakly implies lead_id via "for an LSA lead" and says nothing about business_id or the UUID format requirements, leaving one of two required identifiers 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 (read) and resource (synced Google LSA conversation events for an LSA lead) with an explicit scope limit of 200 events and the content type (customer and advertiser messages). It differentiates itself from generic siblings like get_conversation/list_conversations by tying the resource to LSA leads and to the sync pipeline, though it doesn't name a sibling explicitly.

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?

"Sync first for current history" implies a prerequisite without naming the sync_lsa sibling or stating when this tool should be chosen over get_conversation. The condition is suggested but not spelled out, so usage is inferable rather than explicit.

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

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

Beyond the read-only/idempotent annotations, the description discloses crucial behavioral caveats: the UTC window is start-inclusive and end-exclusive, sync freshness and completeness are included, removed unrated leads are counted separately, and financial/signed-case/response-time metrics must not be inferred. This adds substantial interpretive context that the annotations do not provide.

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 four tight sentences that front-load the report contents, then define the window, then add freshness and completeness context, and finally state data limitations. Every sentence contributes necessary information without repetition 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?

With annotations covering safety and an output schema covering return structure, the description does a strong job of covering the report's scope, temporal semantics, completeness, and interpretation caveats. The notable gap is the unexplained business_id parameter, though its UUID type and required status make its role reasonably inferable.

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

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

Schema description coverage is 0%, so the description carries the burden. It adds essential semantics for the start and end parameters by specifying UTC and inclusive/exclusive boundaries, but it does not explain business_id at all, leaving one required parameter without added meaning.

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 resource and enumerates the exact contents of the report (lead counts, types, statuses, ratings, credit counts) over a defined time window. It is clearly distinguishable from listing or conversation tools, though it does not explicitly name sibling tools like list_lsa_leads or get_lsa_account_report.

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

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

The description explains what the report contains but gives no explicit guidance on when to choose it over alternatives such as list_lsa_leads or get_lsa_account_report. There are no named alternatives, exclusions, or decision criteria for invocation.

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 safety is covered by structured data. The description adds genuinely new behavioral context beyond that: that saved configuration is not proof of a live workflow, and that production access must be verified in Google Cloud rather than in this tool.

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

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

Three short sentences with no filler, and the core purpose is front-loaded before the caveats. The wording is abstract in places but nothing is redundant.

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, and annotations carry the safety profile, but the description still leaves the single required parameter unexplained and gives no context for when this inspection should be run versus related LSA 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?

Schema description coverage is 0% and the sole parameter business_id (a UUID) is never mentioned in the description. The description does not compensate for the coverage gap, leaving the meaning and allowed source of that ID undocumented.

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

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

The description names a specific verb and resource: inspecting Google LSA account selection and sync freshness. It is distinguishable from siblings like get_lsa_account_report or sync_lsa, though it does not explicitly say how it differs from 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?

There is no explicit when-to-use guidance and no named alternative. A sibling like sync_lsa or get_lsa_account_report could plausibly be reached for the same goal, and the description offers no routing logic to disambiguate.

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 readOnly, idempotent, non-destructive, and closed-world. The description adds useful behavior beyond that: results are newest-first, a single fetch includes live status and quota consumption, and it mirrors GET /api/v1/meetings. It omits pagination/limit behavior for the list mode.

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 packs both modes and the quota side-effect with no filler, though it is dense and could be split for easier parsing by an agent. 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?

With an output schema present, return-value structure need not be explained, and the description covers both invocation modes plus quota context. What's missing is list-mode behavior (count, pagination, date bounds) that an agent might need 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?

Schema coverage is 100% and both parameters are already documented in the schema, including the multi-business condition for business_id. The description restates the list-vs-single mode but adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource (list meetings / get one meeting by id) and enumerates what the single-meeting mode returns: live status, minutes used, summary, and plan's remaining minutes. This distinguishes it clearly from siblings like join_meeting, leave_meeting, and get_transcript.

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

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

The description explains the two modes and the condition that selects them ('omit to list recent meetings'), and the schema reinforces that id is optional. It does not name alternative tools for adjacent needs (e.g., transcripts), 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds only framing about the pre-change audit context; it does not disclose anything further about latency, auth scope, or caching behavior that isn't already in the annotations or output schema.

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

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

A single front-loaded sentence with zero filler, though the tail is a dense comma-separated enumeration of fields. It is efficient but reads as a list rather than a tightened statement.

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, idempotent tool with full annotation coverage, a 100%-documented single parameter, and an output schema that carries the return structure, the description is nearly complete. The only shortfall is the absence of explicit sibling routing to the configure_* writes.

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?

Only one optional parameter exists, and the schema documents it at 100% coverage (defaults to first accessible business). The description adds no syntax or fallback detail beyond the schema, 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?

Uses a specific verb ('Audit') plus a clearly-scoped resource ('business-level operational setup') and enumerates the exact contents (alert recipients, alert flags, escalation rules, send-link entries, agent metadata). This content list implicitly separates it from the configure_* write siblings, but it never names a contrasting tool the way a 5 would require.

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

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

Provides clear usage context: this is the read to run 'before changing a live account,' establishing it as a prerequisite for the configure_* mutations. It stops short of naming those alternatives or stating when not to use it, so it falls in the 'clear context, no exclusions' band.

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 it readOnly, idempotent, and non-destructiveikuha. The description adds that it returns both a transcript and a summary screporting the completed-call requirement, which is useful behavioral context 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?

One clear, front-loaded sentence states exactly what the tool does without wasted 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?

With a single documented parameter, an output schema, and annotations covering side effects, the description is nearly complete. It could explicitly note what happens if the call is not completed, but the 'completed call' qualifier conveys the main constraint.

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 is fully described in the schema (100% coverage), so the tool description does not need to add extra meaning. 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 uses a specific verb and resource: 'Get the transcript and summary of a completed call.' It clearly identifies both the payload and the precondition (completed call), which distinguishes it from sibling tools like check_call_status or get_usage.

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 narrows usage to completed calls but does not explicitly mention alternatives, exclusions, or when not to use it. The 'completed call' qualifier gives context, yet an agent isn't told what to use for in-progress calls or where this fits among the many sibling tools.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, but the description adds important context: it may compute missing or stale standing without saving it or sending notifications, badge progress does not raise caps, and levels cannot be set by any tool. This is strong additional behavioral guidance.

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?

Despite the tool's complexity, the description is front-loaded and dense with useful information. Each sentence contributes either scope, mode behavior, safety context, or the sibling alternative.

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 an output schema, annotations, and a complex read-only standing tool, the description covers modes, side-effect behavior, the recheck alternative, and the key constraint that levels are earned. Nothing essential to correct invocation is missing.

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

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

Schema coverage is 100%, and the schema already documents focus values, level, and business_id. The description largely restates focus meanings that are already explicit in the schema, so it adds little meaning beyond the structured 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 and resource, enumerates the trust levels, and distinguishes the tool from the closely named sibling recheck_trust_level. An agent can identify exactly what this tool reads without inferring from the title.

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 explains each focus mode's purpose and explicitly routes agents to recheck_trust_level when they need to recompute and save standing. The alternative and its condition are stated directly.

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 account-scoped behavior and the business-filtering hint, but it does not disclose pagination behavior beyond what the schema already provides. It does not contradict 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 no filler. The core action and scope are front-loaded, and the use-case guidance is a single clause. 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 read-only list tool with a rich output schema, full parameter documentation, and annotations covering safety, the description is nearly complete. The only minor gap is that it doesn't explicitly state when not to use it or mention pagination behavior, but those are covered by the schema and the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (limit, offset, business_id). The description adds a small amount of context by mentioning the business filter implicitly ('this business'), but it does not add 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 uses a specific verb ('List') and resource ('KaiCalls agents on the authenticated account'), and it distinguishes itself from sibling tools by clarifying scope (account-level listing). It also adds a practical use case ('before setting anything up, to see whether this business already has a secretary answering its calls'), which makes the tool's purpose immediately clear.

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

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

The description gives a clear context for when to use the tool ('before setting anything up') and what question it answers ('whether this business already has a secretary answering its calls'). It does not explicitly name alternatives or exclusions, but the context is strong enough for an agent to select it over siblings like list_numbers or list_recent_calls.

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 does not need to repeat those. It adds useful behavioral scope ('for the authenticated business') and the 'outbound' qualifier, giving the agent important access context without contradicting 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 delivers the full purpose without filler or repetition. The differentiating qualifiers 'outbound' and 'authenticated business' are front-loaded, making the description efficient and 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?

The input schema, output schema, and annotations already cover most needed details. It would be slightly stronger if it supplied allowed status values or explicitly directed users to a sibling tool, but for a simple, optional-parameter listing operation the description is adequate.

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

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

Schema description coverage is 100%, so the schema already explains limit, offset, and status. The description adds no additional parameter semantics, which matches the baseline score of 3 when structured data carries the parameter documentation.

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

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

The description states a specific verb ('List') and a well-defined resource ('outbound call campaigns') scoped to the authenticated business. This clearly distinguishes it from sibling tools like create_campaign, list_agents, or list_numbers without relying on the tool name alone.

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—an agent should use this when listing the current business's outbound call campaigns. However, it does not explicitly name alternatives or state when not to use it, though the read-only listing nature makes the intent 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?

Annotations cover read-only/idempotent safety, and the description adds genuine behavioral detail: results are hashed and redacted, version history includes rollback lineage, and passing version returns a full redacted config_snapshot. 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?

Three terse sentences front-load the core operation, then explain the alternate mode and endpoint correspondence. 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?

With an output schema and read-only/idempotent annotations present, the description covers the key behaviors: history listing, snapshot retrieval, and hashing/redaction. No critical missing info 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?

Schema describes all parameters (100% coverage), so baseline is 3. The description adds meaning by explaining the version parameter's effect (return single full snapshot vs list) and noting the data is hashed/redacted.

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

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

States a specific action and resource: 'List an agent's hashed, redacted assistant config version history (rollback lineage included).' This distinguishes it from every sibling tool, and the added behavior for single-version fetch is explicit.

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

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

Clearly describes what the tool does and the conditional use of the version parameter to fetch a single config snapshot. It doesn't explicitly name alternatives or exclusions, but the context is clear enough that an agent knows when to call 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 readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable context by noting it includes the latest AI lead score when available, which is beyond the structured annotations and informs the agent about data content. No contradictions 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?

Two concise sentences with zero filler. The primary purpose is stated first, followed by a single highlight (AI lead score) and a note on filters. Perfectly 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?

Given the tool has an output schema and annotations covering read-only/idempotent behavior, the description is sufficient. It covers scope and filters, and the schema documents pagination. It doesn't mention ordering or edge cases, but with the output schema present and no nested objects, nothing essential is missing 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?

Schema description coverage is 100% and each parameter already has a clear description (limit, offset, source, status, agent_id). The tool description adds only a grouping phrase ('optional status/source/agent filters') which restates the schema without adding new meaning. Baseline 3 is appropriate since the schema handles the semantic load.

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

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

States a specific verb ('List') and a concrete resource ('leads') scoped to the authenticated business, and it names the optional filters (status/source/agent). It clearly distinguishes from the sibling 'get_lead' (single lookup) and 'upsert_lead' (create/update) without needing to open their schemas.

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

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

The description makes clear it lists multiple leads for the current business, which implies it is for browsing/filtering rather than fetching a single lead. It doesn't explicitly name alternatives or state when not to use it, but the context is unambiguous enough that an agent would not confuse it with get_lead or upsert_lead.

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=false, so the safety profile is fully covered and the description correctly does not contradict it. It adds the returned-id semantics but says nothing about pagination behavior despite limit/offset parameters, nor about auth or rate limits.

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 tight sentences with no filler, front-loading the resource and its returned fields before the ID guidance. The enumeration of return fields is slightly redundant against the output schema, but overall it earns its space.

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 the description need not explain return values, and the ID linkage guidance is a genuine value-add. However, with three undocumented input parameters and no usage boundaries, the definition leaves meaningful gaps for a multi-param list 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% for three parameters, so the description carries the full burden — yet it never explains business_id scoping or the limit/offset pagination semantics. The one thing it does clarify (LSA lead id vs lead_id) relates to output, not to the input 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?

States a specific verb and resource ('List synced Google LSA leads') and even enumerates the returned data (charge/credit states, source IDs, rating details). It implicitly distinguishes itself from the generic list_leads sibling via 'synced Google LSA leads', but never names an alternative explicitly.

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

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

The second sentence gives useful downstream guidance — use the returned LSA lead id for LSA commands and the separate lead_id for the CRM — which is implied usage rather than explicit when-to-use. There is no mention of when to prefer this over list_leads or get_lead, and no prerequisites.

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

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

Annotations already convey readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'recent' time scope and 'authenticated business' boundary, but it does not disclose ordering, time-window semantics, or pagination behavior beyond what the schema already provides.

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

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

The description is a single front-loaded sentence with no filler or redundant restatement of the title. It communicates the core action and scope efficiently, earning its place.

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

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

For a simple list tool with fully documented parameters and an output schema, the description is mostly sufficient. However, it leaves 'recent' undefined and does not help the agent decide between this tool and sibling call-related tools, which creates a meaningful contextual gap.

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

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

Schema description coverage is 100%, with every parameter documented (limit, offset, status, agent_id). The tool description adds no additional meaning to these parameters, 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 clear verb and resource: 'List recent calls for the authenticated business'. It distinguishes the tool from list_sms_messages, list_voicemails, and list_conversations by the resource type, but it does not define 'recent' or explicitly differentiate it from call-status or recording 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?

There is no guidance about when to use this tool versus related siblings like check_call_status, get_call_recording, or get_transcript. The description provides no alternatives, exclusions, or preconditions, leaving the agent to infer the appropriate context from the tool name alone.

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

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

Annotations already cover read-only, non-destructive, idempotent behavior. Description adds the 'recent' and 'authenticated business' context, but it does not disclose ordering, pagination behavior, or any rate/access limitations. It does not contradict annotations, so a neutral score 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?

One short sentence that front-loads the core action, resource, scope, and return content. Every phrase earns its place; no 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 read-only listing endpoint, the description plus schema covers the essential context: what is listed, for whom, and what the response includes. The word 'recent' is slightly ambiguous (no time window) but not critical for a basic 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 provides complete descriptions for both parameters (limit, offset), including defaults and bounds. The description adds no additional parameter meaning, so it stays 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?

The description names a specific verb ('list'), a specific resource ('voicemails'), and scope ('for the authenticated business'), and adds key content details ('transcripts and recording URLs') that distinguish it from sibling list tools like list_recent_calls or list_leads.

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 retrieving recent voicemails for the authenticated business, which gives clear context. However, it does not explicitly state when to prefer this over sibling tools or mention any 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's safe. The description adds that the catalog is 'curated' and 'credential-free', and points to a REST endpoint, which helps set expectations of the data source. However, it does not describe the output format beyond listing fields, though an output schema exists. The added context justifies a 3, but not higher because the critical behavioral cues are already in 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 zero fluff. It is front-loaded with the action and resource, followed by a useful note about the REST endpoint. 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 filterable list tool, the description, combined with the input schema and annotations, is complete. It mentions the purpose (configuring agent voices), the output fields, and the credential-free nature. The output schema covers return values. Nothing is obviously 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 has 100% description coverage, with each parameter described as a filter by gender, language, or provider. The description does not add any additional meaning beyond what the schema provides. Per the rubric, with high coverage, the baseline is 3, and the description doesn't elevate it.

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

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

The description clearly states the tool lists a curated voice catalog with specific fields (id, display name, accent, language, gender, sample URL) and mentions it mirrors the REST endpoint GET /api/v1/voices. This is a specific verb (list) and resource (voice catalog), distinguishing it from many sibling list_* tools. The inclusion of 'credential-free' is a helpful qualifier.

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 configuring agent voicesaine, and indicates a REST endpoint. It doesn't explicitly name alternatives or state when not to use it, but the purpose is clear enough. The description's note that it is 'credential-free' could suggest it should be used when no credentials are required, though this is implicit. Since there are no sibling voice-related tools, this is acceptable.

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=false, so the agent knows it is safe to call. The description adds that it returns a ready-to-use config example and is a static catalog, which is useful. However, it does not detail the output structure beyond that, but given annotations cover safety, score 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?

Three sentences long, front-loaded with the core purpose and concrete detailsheb. The second sentence explains when to use it, and the third adds a clarifying constraint. No waste, though it could be slightly more concise by merging the second and third sentences, but overall it is efficient.

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

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

Given zero parameters, rich annotations, and an output schema, the description is complete. It tells the agent why to use it (to get cadence_config example), what it returns (templates with details), and its scope (static). The output schema covers the exact structure, 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?

With zero parametersches, the schema provides no information, so the description carries full burden. It succinctly explains the content of the output (retry interval, defaults, example) which is key for using the tool. Although it does not describe each field in the output schema, that may be covered by the output schema itself. A score of 4 is justified because it clearly communicates what the tool returns without needing parameter 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 clearly states the tool lists workflow templates with specific details (retry intervals, defaults, cadence_config example), distinguishing it from generic list tools. It also explains the purpose of informing create_campaign, which differentiates it from other '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?

Explicitly instructs to call this before create_campaign, providing a clear use case and routing rationale. It also mentions that it is a static catalog with no per-business state, which implies when it might not be needed (e.g., for dynamic data), and indirectly contrasts with create_campaign.

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?

Adds substantial context beyond the annotations: it replaces saved derived state, may record level-change history, may email the owner on standing changes, and cannot set or raise a level by request. This aligns with destructiveHint=true and gives the agent enough warning about side effects.

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

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

The description is dense but front-loaded, with each sentence adding useful operational context. The dashboard analogy and the explicit side-effect disclosure earn their 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 destructive mutation tool with an output schema, this covers the key behavioral risks: saved state replacement, history/email side effects, membership requirement, and the inability to manually raise a level. Nothing important for correct invocation 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%, and the schema already explains focus, level, and business_id semantics. The description does not add further parameter meaning beyond saying it operates on one business, 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?

States a specific verb and resource: recompute one business's trust level from live activity and save it. It also distinguishes itself from get_trust_level by noting that it returns the same view plus movement and persists the recomputed state.

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

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

Gives clear usage context, especially right after an owner adds a card, and notes the current-business-membership requirement. It does not explicitly frame get_trust_level as the read-only alternative, but the recompute-and-save distinction is clear.

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