Coordinalo — Service Business Operations

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

With no annotations, the description carries the full burden and meets it admirably. It discloses that services are auto-discoverable by default, auto-assigned when there is exactly one active provider, and that unassigned services block admin_toggle_discoverable. It also states the required X-Org-Api-Key header, providing rich behavioral and authentication context.

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

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

The description is dense but front-loaded with the core purpose. Four sentences pack significant workflow and behavioral detail without wasted words. The structure could be slightly clearer by separating the auth requirement, but overall it is efficient for the amount of 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 an 8-parameter creation tool with no output schema and no annotations, the description provides strong contextual completeness: preconditions, assignment behavior, blocking condition, and next steps. The main gap is lack of return-value or parameter details, but the workflow context is well covered.

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

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

The schema has 0% description coverage, and the description does not compensate. It never explains parameters like orgSlug, duration_minutes, price, currency, vertical, or apiKey. While the purpose mentions "organization" and "provider schedule," there is no mapping to specific parameters, leaving the agent guessing about parameter formats, constraints, or relationships.

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: "Add a bookable service to an organization." It uses a specific verb and resource, and the context about auto-discoverability and auto-assignment hints at admin-specific behavior, distinguishing it from generic siblings like service_create. However, it does not explicitly contrast with alternative service creation tools, so it falls short of a 5.

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

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

The description explicitly says "Use after admin_create_organization," providing a clear precondition. It also names alternatives: "use service_assign_provider to assign manually" and "Next step: admin_set_availability." This is exemplary guidance for when and how to use the tool within the workflow.

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

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

With no annotations, the description carries the burden and adds value by disclosing the auth header requirement and the auto-provisioning behavior of the org owner. It could mention pagination or response shape, but for a read-only list operation it's reasonably transparent.

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

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

The description is four compact sentences, each earning its place: purpose, usage, behavioral nuance, and auth requirement. No fluff 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?

It covers purpose, usage, auth, and a relevant behavioral quirk, but lacks parameter-level clarity and doesn't describe the response fields (e.g., providerId) despite having no output schema. Adequate but with clear gaps.

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

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

Schema coverage is 0%, and the description only vaguely alludes to 'an organization' (implying orgSlug) without explaining the orgSlug parameter. The apiKey parameter is entirely unaddressed, especially in relation to the X-Org-Api-Key header.

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 active providers (professionals) for an organization, using a specific verb and resource. It distinguishes itself from siblings like provider_get by focusing on listing active providers for an org context.

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

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

Explicitly says 'Use this to get providerId before calling admin_set_availability' and notes the required X-Org-Api-Key header. It gives clear context and prerequisites, though it doesn't mention when not to use it.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It explicitly warns that the operation overwrites all existing blocks, which is the key destructive trait, and also mentions the required header and time format. This is strong disclosure for a mutation tool, though it could mention irreversibility or error handling.

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, each with a distinct purpose: main action with critical caveat, prerequisite, and format/auth details. Front-loaded and no wasted words, making it easy to parse quickly.

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

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

Given the tool's complexity (4 parameters, no annotations, no output schema), the description covers the destructive behavior, input format, auth requirement, and how to obtain providerId. It could mention the return value or error scenarios, but for a setter tool, the essential context is present. The sibling availability_get_provider_schedule exists, but a cross-reference is not strictly necessary.

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 0% description coverage, so the description must compensate. It explains the schedule format ('day names and HH:MM times') and mentions that providerId comes from admin_list_providers. It also implies the apiKey is the X-Org-Api-Key header. However, orgSlug is not explained, and the description does not fully cover all parameter meanings, leaving a gap.

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 replaces the weekly availability schedule for a provider, with a specific verb ('Replace') and resource. It distinguishes from siblings by emphasizing 'not additive — overwrites all existing blocks,' which is a key differentiator from merely adding or updating availability.

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 usage guidance by stating to get providerId from admin_list_providers first, and it clarifies when to use this tool by noting it overwrites rather than adds. It does not explicitly name alternative tools, but the context is clear enough for an agent to understand when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool flips local flags but does not publish without Organization.discoveryConsent=true, requires the X-Org-Api-Key header, and that cron/resolver skip non-consented orgs. This goes well beyond a simple 'toggle' and provides important side-effect context.

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

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

The description is detailed but front-loaded with the core action in the first sentence. Each warning serves a critical purpose, and the flow from action to limitation to consequence to auth requirement is logical. No sentence is wasted.

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 lack of annotations, output schema, and schema descriptions for the 3 parameters, the description covers all essential aspects: what the tool does, when it has no effect, who can grant consent, the auth header, and downstream behavior. It is highly complete for an agent to make an informed call.

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

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

The schema has 0% description coverage, so the description must compensate. It clarifies the semantics of the `discoverable` parameter (local flag only, not actual publication) and maps `apiKey` to the required X-Org-Api-Key header. However, `orgSlug` is not explicitly described, though its purpose is inferable from the operation.

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?

Clearly states the tool's function: toggling the LIFECYCLE flags isPublic and servicialoPublished. This specific verb+resource combination distinguishes it from sibling tools like lifecycle_transition and admin_update. The consent warning doesn't obscure the primary 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?

Explicitly describes when this tool should not be relied upon (non-consented orgs) and names the alternative: human owner via PATCH endpoint. It also explains the consequence of using it without consent, telling the agent when to expect no publication. This is strong when/when-not guidance.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that the created agenda is public and gains a URL, and that it links to a provider/service. However, it does not mention auth requirements, failure modes, validation rules, or side effects like slug uniqueness.

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 focused sentences: what it creates, how it links, its public URL, and when to create it. It is front-loaded and every sentence adds value without being verbose.

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

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

With 19 parameters, no output schema, and no annotations, this description is insufficient for an agent to confidently invoke the tool correctly. It omits return value shape, defaults for flags like isPublic, and the meaning of many configurable enums and options.

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

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

Schema description coverage is 0%, so the description should compensate for 19 parameters. It only indirectly explains orgSlug and slug through the URL pattern /{orgSlug}/agenda/{slug}. Most parameters like assignmentStrategy, bookingFlowOrder, or serviceSelectionMode are left unexplained.

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

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

The description clearly states what the tool does: creates a public agenda, a shareable booking page, and links it to a provider and/or service. It distinguishes itself from sibling tools like agendas_update and agendas_delete by focusing on creation and the resulting public URL.

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

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

It explicitly says to create this after services and availability are configured, giving a clear prerequisite context. It also explains the consequence of not having a public agenda (clients can only be booked via API or dashboard), which helps agents decide when to use this tool.

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

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

With no annotations provided, the description carries the full burden and does so excellently. It discloses the destructive nature (permanent deletion), the cascade effects on related sessions/comments/service configs, the confirm requirement, and irreversibility. This goes beyond simple 'delete' and gives the agent essential safety information.

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 three sentences, each carrying a distinct piece of information: action and permanence, cascading effects, and confirm requirement plus irreversibility. There is no filler or redundancy; perfect conciseness for the needed 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 destructive tool with no annotations and no output schema, this description covers the essential aspects: what is deleted, the extent of deletion (cascade), the required confirmation flag, and irreversibility. It provides enough context for an agent to safely invoke the 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%, so the description must compensate. It adds semantic value for 'confirm' (requires true) and 'agendaId' (cascade effects on related data), but it does not clarify 'orgSlug', 'agendaId' identification, or 'apiKey' usage. The compensation is partial, so a mid-range score is appropriate.

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

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

The description uses the specific verb 'Delete' with the resource 'public agenda', explicitly states 'permanently' and 'Cannot be undone', which clearly distinguishes this destructive action from sibling tools like agendas_update or agendas_get. The scope is unambiguous.

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

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

The description provides clear operational context: requires confirm: true, cascades to related sessions/comments/service configs, and is irreversible. This effectively implies when to use it (only when permanent deletion is intended) but does not explicitly name alternatives or provide when-not-to-use exclusions, so it falls slightly short of full usage guidance.

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

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

With no annotations, the description carries the full burden and enumerates return content: booking flow, selection modes, assignment strategy, privacy settings, linked provider/service, and session count. It clearly labels the agenda as 'public' but does not address auth failures or error behavior, so it's not a perfect 5.

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 sentence description, front-loads purpose in sentence one and packs return details plus usage advice in sentence two. No redundant filler.

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

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

For a simple get-by-ID tool, the description covers purpose, return payload highlights, and a usage context. Missing edge-case behavior (private agenda handling, 404 responses) but sufficient for basic 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?

The only parameter hint is 'by ID' suggesting agendaId; the description does not explain orgSlug or apiKey. With 0% schema coverage, the description fails to compensate for the undocumented parameters, though the parameter names are fairly self-explanatory.

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

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

The description opens with a specific verb and resource: 'Get complete details of a public agenda by ID.' It clearly distinguishes itself from sibling list/create/update tools by focusing on retrieval of a single agenda's full configuration.

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 states 'Use before agendas_update to inspect current settings,' providing a concrete workflow and differentiating from update. It also implies the tool is for single-agenda reads rather than listing via agendas_list, though it doesn't enumerate all 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that it returns agendas and mentions the 'public' nature, but does not disclose whether authentication is needed (despite an apiKey parameter), possible pagination, rate limits, or any side effects. The read-only nature is implied by 'List' but not explicitly declared.

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 concise, consisting of a single sentence that front-loads the core action and resource. The additional detail about return content is relevant and earns its place. No unnecessary words or filler.

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

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

For a simple list operation with two parameters and no output schema, the description provides the essential purpose and return overview, which is adequate but incomplete. It lacks parameter descriptions and usage context, but the tool is simple enough that the agent can partially infer from the schema names. The description is not as complete as it could be given the absence of annotations and output schema.

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

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

The schema description coverage is 0%, so the description must compensate for the lack of parameter explanations. However, it does not mention orgSlug or apiKey at all, and only weakly alludes to the organization via 'for an organization'. The agent cannot derive parameter meaning from the description beyond what the parameter names already suggest.

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

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

The description clearly states the verb 'List', the resource 'public agendas', and the scope 'for an organization'. It also mentions the response content (provider, service, session counts), which helps distinguish it from other agenda tools like agendas_get or agendas_create. The purpose is unambiguous and well-defined.

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 listing public agendas) but does not explicitly state exclusions or alternatives. It could mention that for a single agenda, agendas_get is appropriate, but such guidance is missing. The context is clear but not fully developed.

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?

Discloses partial update behavior and auto-linking side effect when a provider is assigned. No annotations are provided, so description carries burden; it covers key behaviors but omits permissions and error handling.

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 front-loaded with purpose and partial-update note, then compactly lists supported modifications in a structured manner. 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?

Despite 23 parameters and no output schema, the description conveys core semantics and side effects, but lacks details on return values, validation, or required fields beyond the obvious; still adequate for most use cases.

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

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

With 0% schema description coverage, the description compensates by enumerating updatable fields, enum values for bookingFlowOrder, assignmentStrategy, selection modes, and boolean privacy flags. However, it does not mention all 23 parameters, leaving some like slug, apiKey, expiresAt 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 clearly states 'Update a public agenda’s configuration' with a specific verb and resource, and distinguishes from sibling tools like agendas_create/delete/list/get by focusing on modification.

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

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

The description implies usage for modifying an existing agenda by listing updatable fields and partial update semantics. It does not explicitly contrast with alternatives but provides enough context to infer when this tool is appropriate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clarifies that the tool returns the configured base schedule, not dynamic free slots, which is a key behavioral nuance. However, it does not mention potential errors, authorization requirements, or return format, but for a simple getter, the provided transparency is above average.

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 concise sentences. The first sentence front-loads the core purpose and includes a clarifying parenthetical, while the second sentence directs to the modifier. Every word earns its place with no fluff.

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 getter with no output schema, the description is largely complete: it names the resource, clarifies the scope, and points to the relevant modification tool. It does not mention required parameters or response details, but the schema covers parameter names and the purpose is clear enough for an agent to use correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings or formats. It does not mention orgSlug, providerId, or apiKey at all. While parameter names are self-explanatory, the description adds no semantic value beyond what the schema already provides, which is nothing.

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

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

The description clearly states the verb 'Get' and the resource 'configured weekly availability schedule for a provider'. It also distinguishes itself from sibling tool availability_get_slots by explicitly noting 'not free slots, but the base configuration', and references admin_set_availability for modification, making the purpose unambiguous.

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

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

The description provides explicit usage guidance: it tells the user this tool is for the base configuration, not free slots, implying that availability_get_slots should be used for free slots. It also points to admin_set_availability as the tool for modifying the schedule, thereby giving clear 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?

With no annotations, the description bears full burden, and it delivers: it discloses agenda-awareness, org-controlled public exposure, provider resolution with clientId fallback, and that modes 1–3 hide provider details. It is less forthcoming about authentication/authorization requirements and pagination/error behavior.

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

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

The description is a dense but organized paragraph; the first sentence states the core, and the numbered modes make the combinatorial behavior digestible. It does not waste words, though the length is high for a single-paragraph description.

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

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

The description covers the five modes, fallback logic, and provider visibility; this is substantial for a tool with no output schema. Missing return format details and edge-case behavior (overlapping params, defaults) are the main gaps.

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

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

Schema coverage is 0%, and the description compensates by mapping five mode-specific parameter combinations (orgSlug, clientId, agendaId, serviceId, providerId) and a date range. However, it leaves duration, timezone, and apiKey semantics entirely to the schema (which has no descriptions), so the compensation is partial.

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 ('Query') and resource ('available time slots'), defines the date-range scope, and differentiates five invocation modes tied to parameters. It clearly distinguishes from siblings like availability_get_provider_schedule by explaining the agenda/provider resolution behavior.

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 explicit usage context: 'Use before booking_create' and enumerates five modes, explaining when each parameter combination is appropriate. However, it does not name sibling alternatives or state when not to use this tool, so it stops short of full exclusivity guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly explains that by default the org cancellation policy applies, how the charge is computed (no-charge/partial/full windows), that a penalty transaction may be registered if autoApply is set, and that applyCancellationPolicy: false waives the charge. It also warns that confirm: true is required. This is extensive and transparent about side effects (money-write).

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 three sentences long and highly efficient. The first sentence states the core purpose, the second explains the default policy behavior and side effects, and the third gives the override option. Every sentence adds value, with no filler or repetition.

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

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

Given the tool has no output schema and no annotations, the description covers the main behavioral context: cancellation policy, charge computation, penalty registration, the override flag, and the confirm requirement. It does not describe the return value or error scenarios, but for a mutation tool with this level of behavioral detail, it is reasonably complete. Missing details like what happens if confirm is false or when the policy doesn't autoApply are implied but not explicit.

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 7 parameters with 0% description coverage. The description compensates by explaining the semantics of applyCancellationPolicy (waive charge) and confirm (must be true), which are critical. However, it does not clarify the meaning of reason, cancelledBy, orgSlug, sessionId, or apiKey beyond their names, so the compensation is partial.

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 function: 'Cancel an existing session.' It also specifies the resource (session) and the action (cancel). However, it does not explicitly distinguish this from sibling cancel tools like scheduling_cancel or portal_session_cancel, though the mention of org cancellation policy adds some differentiation.

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

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

The description provides context about the default behavior (applying cancellation policy) and how to waive it, but it does not explicitly state when to use this tool versus the other cancel-related tools in the sibling list. The usage is somewhat implied by the org-specific policy details, but no exclusions or alternative tool references are given.

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

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

With no annotations provided, the description carries full behavioral burden. It discloses extensive details: optional providerId with auto-assignment strategy, titular provider preference, default public agenda, retroactive behavior (skips slot validation, sets status to completed, tags self_declared provenance, max 365 days), autoCharge effect, and auto-detection of past dates. This is exceptionally transparent.

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

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

The description is dense but structured, with preconditions, usage guidance, and specialized behavior clearly stated in separate sentences. It is longer than average but every sentence adds value. Slight loss for being somewhat lengthy, but justified by the tool's complexity.

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

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

For a tool with 14 parameters, no output schema, and no annotations, the description covers most critical behavioral context: preconditions, slot validation, retroactive logic, and provider assignment. It falls short by not describing the return value or side effects like notifications, and it omits several parameter semantics. Overall, it is quite complete for a complex booking 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 coverage is 0%, so the description must compensate. It explains key non-obvious parameters: providerId, publicAgendaId, retroactive, autoCharge, and retroactiveStatus (implied via 'completed by default'). However, it does not mention duration, modalidad, notes, or idempotencyKey, leaving some parameters semantically undocumented. Still, it adds substantial 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 a specific verb+resource: 'Create a new session/appointment for a client.' It immediately distinguishes this from sibling tools by detailing unique behaviors such as provider auto-assignment, agenda selection, and retroactive booking. The scope is clear and unambiguous.

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

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

The description explicitly names preconditions and related tools: 'Use availability_get_slots to find valid time slots before calling this' and 'client must exist (use client_create first).' It also explains when to use retroactive and autoCharge flags. This gives concrete guidance on when and how to invoke the tool.

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

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

With no annotations, the description discloses key behaviors: it generates multiple sessions, links them via a series ID, and caps at 52 occurrences. This goes beyond the basic 'create' action, though it omits details like confirmation or conflict handling.

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, front-loaded sentences with no redundancy. The primary action is first, and the second sentence adds value without wasting 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 complex nested schema (10 parameters, recurrence object, no output schema), the description is far too high-level. It lacks parameter semantics, behavior on conflicts, confirmation requirements, and return format, making it insufficient 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 0%, and the description provides no explanation of any of the 10 parameters (e.g., orgSlug, clientId, recurrence, timezone, confirm). It fails to compensate for the schema's lack of 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 creates recurring sessions, gives a specific example ('weekly therapy'), and distinguishes it from single-booking siblings like booking_create by explaining it generates multiple linked sessions with a recurrence series ID.

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 conveys that this is for creating recurring sessions, with a relevant example, and implies it's for multi-occurrence bookings. However, it does not explicitly name alternatives or state when not to use this tool.

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

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

No annotations are present, so the description carries the burden. The verb 'Get' implies a non-destructive read, but no additional behavioral traits are disclosed (e.g., authentication requirements, error handling, or side effects). It is adequate but sparse.

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 with no wasted words. It efficiently conveys the core purpose and scope of returned data.

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

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

For a simple get-by-ID tool, the description lists the main data categories, which partially compensates for the lack of an output schema. However, with no annotations and no parameter guidance, it leaves gaps about invocation context and response structure.

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

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

Schema coverage is 0%, so the description must compensate. It hints at 'by its ID' for sessionId, but does not explain orgSlug or apiKey. The description adds minimal value beyond the raw parameter names; the agent would have to infer the role of each parameter.

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

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

The description clearly states the tool retrieves a session/appointment by ID and lists the categories of details included (client, provider, service, financial, delivery proof). This distinguishes it from list and mutation tools like booking_list and booking_cancel.

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

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

The description implies usage for fetching a single session's full details, but does not explicitly state when to prefer this over alternatives like booking_list or public_booking_get, nor are there exclusions or when-not-to-use conditions.

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

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

The description discloses cursor-based pagination, which is a useful behavioral trait. However, with no annotations, it does not mention authentication (apiKey), required orgSlug, default ordering, or potential error behavior. It adds some transparency but leaves significant gaps.

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

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

Two sentences, front-loaded with the primary action and resource, followed by filter and pagination details. No redundant information; 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 11 parameters, no output schema, and no annotations, the description should provide more context. It omits required parameter orgSlug, return format, default sort order, and parameter value formats. While it covers filters and pagination, it is insufficient for a tool with such high complexity.

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

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

With 0% schema description coverage, the description compensates by naming filter dimensions (provider, client, service, status, date range) and pagination. However, it omits several parameters like orgSlug, limit, cursor, orderBy, and apiKey, so it only partially explains the parameter space.

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 function: 'List sessions for an organization' with specific filter dimensions (provider, client, service, status, date range). This distinguishes it from sibling tools like booking_get (single booking), booking_list_requests (requests), and scheduling_book (creation).

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 listing sessions with filters, but does not explicitly state when to prefer this over alternatives such as booking_list_requests or provide exclusion criteria. The 'for an organization' context is clear, but no explicit guidance or alternative references are given.

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

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

With no annotations, the description carries the full burden. It discloses that the operation is read-only, lists what is returned (proposed slot, current session state, proposer), and mentions cursor pagination. It does not cover auth/rate limits, but the key behavioral traits are conveyed.

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 yet dense; every clause adds value. The first sentence is front-loaded with the core purpose, and subsequent sentences efficiently cover filters, return data, pagination, optional flag, read-only nature, and alternate action tool 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 list tool with 8 parameters and no output schema or annotations, the description is largely complete: it covers purpose, filters, return contents, pagination, and related tool. Minor gaps include explicit mention of the limit parameter and required orgSlug, but these are not critical for 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 0%, so the description must compensate. It adds meaning by documenting status values and default (pending|all|resolved), sessionId/clientId filters, includePendingCount purpose, and pagination. It omits explicit details for limit, apiKey, and orgSlug, but orgSlug is implied by 'organization' and apiKey is likely authentication.

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 identifies the resource 'reschedule requests (SessionRequest) of an organization', clearly distinguishing this from sibling tools like booking_resolve_request (action) and booking_list (general bookings). The mention of the 'org side of the bilateral coordination loop' adds context that separates it from client-side portal 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?

It clearly states this is for the organization side of reschedule requests and explicitly recommends 'Use booking_resolve_request to approve or reject one', providing an alternative. Filtering options and default status are also specified, giving the agent clear when-to-use guidance.

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

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

With no annotations, the description carries the burden. It transparently discloses that the original is canceled and a new one created, plus the confirm requirement. Still lacks details on permissions or other side effects, but covers key behavioral traits.

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

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

The description is two sentences, front-loaded with the core action, and every word earns its place. No redundancy or filler.

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

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

The tool has 7 parameters, no annotations, and no output schema. The description offers a solid high-level overview (cancel/create, confirm requirement) but omits details like timezone handling or conflict behavior. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'confirm' but does not explain most parameters like 'newProviderId' or 'reason'. Many parameters are left undocumented in both schema and description.

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

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

The description uses a specific verb 'Reschedule' with a clear resource 'session' and target 'new time'. It explicitly distinguishes from siblings like booking_cancel and booking_create by explaining the cancel-and-create mechanism.

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 a clear prerequisite ('Requires confirm: true'), giving context on when to use. However, it does not explicitly mention alternatives or when not to use it, but the requirement provides practical guidance.

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

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

With no annotations, the description fully discloses important behaviors: atomic application of approval, rejection reason requirement (min 10 chars), idempotency with conflict return, and emission of session lifecycle events. This exceeds typical transparency for mutation tools.

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 three sentences, each adding substantive value: purpose, outcome details, and behavioral guarantees. No redundant phrasing, and the information is front-loaded with the core action in the first sentence.

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

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

For a mutation tool with no annotations or output schema, the description covers purpose, side effects, idempotency, and validation. It doesn't describe the success response format, but this may be acceptable given the output is likely a standard status object. Overall, it's adequate for an agent to invoke correctly.

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

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

The description adds essential semantics for outcome (approved/rejected meanings) and reveals a minLength constraint on reason not present in the schema. However, requestId, orgSlug, and apiKey are left to inference, which is acceptable given their common usage but not fully compensated for with 0% schema coverage.

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

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

The description clearly states the tool's purpose: 'Approve or reject a pending reschedule request (SessionRequest) that a client proposed from the portal'. It uses specific verbs (approve/reject) and identifies the resource (pending reschedule request), distinguishing it from sibling tools like portal_propose_reschedule and booking_reschedule.

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 strong contextual guidance by indicating this is for resolving client-proposed requests, including atomic approval and rejection criteria. It doesn't explicitly list alternatives, but the phrase 'closes the bilateral coordination loop' implies the appropriate workflow stage. The idempotency note also clarifies what happens if used incorrectly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal a key limitation (deliver unavailable due to MCP authentication constraints), but it does not disclose other important behaviors such as whether actions are reversible, required permissions, side effects, or response format. For a state-changing tool, this is a significant gap.

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

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

The description is somewhat long but every sentence carries weight: it defines the tool's purpose, lists actions, and provides a critical security constraint with a concrete alternative. The structure is logical, though the REST endpoint detail could be trimmed without losing the core warning.

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 (7 params, 3 enums, no output schema) and lack of annotations, the description is incomplete. It covers only the action list and the 'deliver' exclusion, but omits parameter details (e.g., noShowType, deliveryType, notes), error conditions, permission requirements, and return values. A more thorough description is needed for reliable 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 0%, so the description must compensate by explaining parameters. It only lists the action values (confirm, start, complete, no-show), which is already present in the enum, and provides no explanation for notes, noShowType, deliveryType, apiKey, or how they relate to each action. This adds no semantic value beyond the schema.

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

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

The description clearly states a specific verb ('Advance') and resource ('session through the Servicialo lifecycle'), enumerates the exact actions available (confirm, start, complete, no-show), and explicitly distinguishes itself by noting the 'deliver' action is not available via MCP. This effectively differentiates from sibling tools like booking_cancel or booking_reschedule.

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 for when to use the tool (to advance a session lifecycle) and explicitly states an exclusion: the 'deliver' action is not available and must be done via a REST endpoint, naming that endpoint. However, it does not compare against other lifecycle-related siblings like lifecycle_transition, so guidance is strong but not fully exhaustive.

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

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

With no annotations, the description carries the burden of behavioral transparency. It discloses that the operation 'Freezes the period,' which implies irreversibility, and states the confirm requirement. However, it doesn't elaborate on potential side effects beyond freezing or error behavior if preconditions aren't met.

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 covers purpose, precondition, and confirm requirement without waste. Every clause adds value and is front-loaded with the primary action.

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

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

The description provides core context (action, precondition, freeze, confirm) but misses details about the meaning of 'orgSlug' and 'periodo,' and doesn't state what the response contains (no output schema). It's adequate for a simple close operation but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains 'confirm' (must be true). It does not clarify 'orgSlug' or 'periodo,' which are core parameters. 'apiKey' is self-explanatory, but the lack of explanation for two required parameters is a significant gap.

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 'Close the organizational period' with a specific verb and resource. It distinguishes itself from sibling tools like cierre_crear_cliente or cierre_listar_clientes by focusing on closing the period, though it doesn't explicitly compare to those alternatives.

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

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

The description provides explicit preconditions: 'Requires ALL active clients with historialCompleto=true to be closed first' and 'Requires confirm: true.' This helps the agent know when to invoke the tool, but it doesn't mention alternatives or when not to use it, leaving a slight gap.

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

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

With no annotations, the description carries the full burden. It adds meaningful behavior context such as 'immutable financial snapshot' (result is immutable) and the uniqueness constraint. It does not disclose error behavior, permission requirements, or return format, so it's partial.

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

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

The description is four short sentences, each adding value: purpose, prerequisite, constraint, and confirm requirement. It is front-loaded and free of 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?

The description covers the core purpose, key prerequisites, and a critical constraint, but lacks details on return values, error handling, and the significance of the immutable snapshot in practice. Given the financial nature and no output schema, more would be helpful, though the essential invocation criteria are 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 0%, so the description must compensate. It interprets 'confirm' ('Requires confirm: true') and 'periodo' ('per period'), but leaves orgSlug, clientId, notas, and apiKey unaddressed, providing limited added value beyond the schema.

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

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

The description clearly states 'Create a client monthly closing' with the clarifying parenthetical 'immutable financial snapshot,' specifying the verb and resource. This distinguishes it from sibling tools like cierre_listar_clientes (list) and cierre_eliminar_cliente (delete).

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

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

The description provides clear context for when to use the tool by specifying prerequisites ('Requires historialCompleto=true on the client') and a unique constraint ('One closing per client per period'). It also notes the confirm parameter requirement. However, it does not explicitly contrast with sibling tools or state when not to use it, so it falls short of a full 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?

With no annotations provided, the description carries the burden of disclosing behavioral traits. It mentions a significant side effect: 'Freezes the current period and all prior open periods,' and implies destructiveness via 'Requires confirm: true.' However, it omits reversibility, error conditions, or authorization requirements, leaving some gaps for a mutation operation.

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

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

Three concise sentences, front-loaded with the core purpose, followed by prerequisites and required confirmation. Every sentence adds value with no redundancy.

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

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

For a tool with no output schema and moderate complexity, the description covers purpose, prerequisites, a key side effect, and confirmation requirement. However, it leaves several parameters (orgSlug, apiKey, montoDistribuido) without detailed explanation and does not mention return values or error behavior, making it adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to 'periodo' (must be organizationally closed) and 'confirm' (must be true). 'montoDistribuido' is implied by 'profits,' but orgSlug and apiKey are unexplained. Partial coverage, so a mid-range score 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 ('Distribute profits') and the context ('for a closed period'), making it distinct from sibling tools like cierre_cerrar_org (closing the organization) and cierre_listar_utilidades (listing profits). It gives a specific verb+resource with additional scope.

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 an explicit prerequisite: 'Requires the period to be organizationally closed first.' It also states the need for confirm:true, which is a usage condition. It doesn't mention alternatives or when not to use, but the prerequisite is valuable guidance.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It discloses the precondition (not frozen) and the requirement for confirm=true. However, it does not explain what the delete/reopen actually does in terms of side effects, reversibility, or what happens to associated records. The word "reopen" hints at restoring state, but this is not explicit.

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, front-loaded with the core action. Every clause adds useful information: the action, the parenthetical clarification, the precondition, and the required confirm flag. There is no fluff 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?

For a delete/reopen operation with no annotations and no output schema, the description provides essential context (precondition, confirmation) but lacks details about error conditions, return values, or consequences. It is not severely under-specified like the lowest examples, but it leaves gaps for an AI agent to assess the full impact of the 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 0%, so the description must compensate. It only mentions "confirm: true" as a required flag, which gives some meaning to that parameter. The other parameters (apiKey, orgSlug, cierreId) are not explained; their meanings are left to inference from names. The description does not clarify the role of cierreId beyond implying it is the closing being deleted.

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

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

The description states a specific verb and resource: "Delete (reopen) a client closing." This directly clarifies that the tool operates on a client closing, not a client, distinguishing it from sibling tools like cierre_crear_cliente and cierre_listar_clientes. The parenthetical "reopen" adds scope and nuance, making the action unambiguous.

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

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

The description provides clear context for when the tool is allowed: "Only allowed if the organizational period is not frozen." This is a defining precondition. It does not explicitly name alternatives or say "use this instead of X," but the condition and the action (reopen) imply it is for undoing a closing, which is sufficient context given 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It lists return values but does not explicitly state that the operation is read-only or has no side effects. The verb 'Evaluate' implies safety, but this is not confirmed.

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 a clear purpose and a structured list of return values. No filler words; every word earns its place.

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

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

The return values are explained, but the tool's role in the closing workflow, prerequisites, and parameter semantics are missing. Given 3 parameters, no output schema, and no annotations, this is a notable 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?

With 0% schema description coverage, the description should explain apiKey, orgSlug, and periodo. It only hints at 'period' and 'organizational' but leaves apiKey and parameter formats 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 clearly states 'Evaluate organizational closing readiness for a period' with a specific verb and resource, and lists return values that distinguish it from sibling tools like cierre_cerrar_org.

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

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

No explicit when-to-use or alternatives are mentioned. The phrase 'Evaluate readiness' implies it is a pre-check for closing, but the description does not explicitly say 'use before cierre_cerrar_org' or exclude other contexts.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It conveys that this is a read-only listing operation with optional filters, but it does not mention return format, pagination, auth requirements, or potential performance implications.

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

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

The description is two sentences, front-loaded with the core action and scope, and every word contributes. It is concise without sacrificing clarity.

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

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

With no output schema and no annotations, the description should explain return values and parameter specifics. It covers the basic purpose and filters but omits auth requirements, period format, output shape, and any pagination details, leaving meaningful gaps for a 4-parameter 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%, so the description must compensate. It adds meaning by indicating 'period' and 'client' are filter parameters, mapping to periodo and clientId. However, it does not explain the format of periodo, the nature of clientId, or the roles of apiKey and orgSlug beyond their names.

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

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

The description clearly states the action ('List') and resource ('client closings') with an organization scope. It is distinct enough from siblings like cierre_listar_utilidades by specifying 'client closings', though it does not explicitly differentiate from other list tools.

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

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

No guidance is provided on when to use this tool versus alternatives such as cierre_listar_utilidades or other list tools. There are no exclusions, prerequisites, or contextual hints beyond the basic filtering options.

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

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

No annotations are provided, so the description alone must convey behavior. It discloses the return structure (per-period records with accumulated totals) but omits details like authorization requirements, pagination, or whether it only returns retained earnings versus other financial data. 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?

The description is a single, focused sentence that front-loads the action and resource. It immediately adds return-value context, with no wasted words.

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

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

For a simple list endpoint, the return-field summary is helpful, but the lack of parameter explanations and usage context makes it incomplete. Missing details like optional filters, ordering, or required authentication could lead to incorrect calls.

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

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

Schema description coverage is 0%, and the description does not name or explain parameters. It mentions 'organization' which hints at orgSlug, but apiKey is left entirely to inference. Parameters lack syntax, format, or required-status context beyond the schema.

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

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

The description uses a specific verb ('List') and identifies the resource ('retained earnings') and scope ('for an organization'). It also differentiates from sibling tools by specifying the output fields, making its purpose unmistakable.

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

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

No explicit guidance on when to use this tool versus alternatives is given. The context of 'utilidades retenidas' and sibling tool names (e.g., cierre_distribuir_utilidades) implies a distinct niche, but the description doesn't state exclusions or alternative scopes.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that the operation is a preview and non-mutating ('WITHOUT creating the closing'), and it lists the returned totals. However, it does not mention permissions, error conditions, or behavior when data is missing, leaving moderate gaps in transparency.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and includes the critical non-mutating qualifier. It lists the output totals concisely, with no wasted words or repetition.

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

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

The tool has no output schema, no annotations, and incomplete parameter documentation. The description covers the basic action and return values but omits essential details like parameter formats, required authorization, or edge-case behavior. For an agent to use this tool correctly, it would need additional context that is not provided.

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

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

The schema has 0% description coverage, and the description does not explain any parameter. It only implicitly maps 'client' and 'period' to clientId and periodo, leaving apiKey and orgSlug unexplained, and the format of 'periodo' is entirely unspecified. The description fails to compensate for the lack of schema information.

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

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

The description clearly states the tool's purpose: to preview a financial snapshot for a client in a period without creating the closing. It specifies the exact outputs (totals for ventas, cobros, pagos, sessions), and the phrase 'WITHOUT creating the closing' distinguishes it from sibling closing operations like cierre_cerrar_org.

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 for when to use the tool: to preview the client's financial snapshot before performing a closing. It explicitly notes that it does NOT create the closing, implying a safe, read-only use case. However, it does not explicitly name alternative tools or state exclusions, which is why it doesn't reach 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does disclose a critical behavior: same-email linking prevents duplication. However, it omits other important behaviors such as error handling, idempotency guarantees, required field implications, and return value. This partial disclosure is valuable but incomplete for a write operation.

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

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

The description is just two sentences, front-loaded with the action, and contains no superfluous information. Every word earns its place: the first sentence states the core action, the second adds a key behavioral nuance.

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 12 parameters, no output schema, and annotations are absent, the description offers far too little: no guidance on which parameters are required beyond the schema, no indication of response format, no failure scenarios, and no usage context. The one de-duplication detail is useful but insufficient to fully understand the tool's behavior and 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?

The input schema has zero description coverage, and the description adds meaning only for the email parameter via the linking behavior. The other 11 parameters (rut, name, lastName, notes, phone, apiKey, comuna, orgSlug, idempotencyKey, proveedorTitularId, direccion) remain semantically opaque, leaving the agent to guess from names alone. The description does not compensate for the low 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 begins with a specific verb and resource: 'Create a new client in the organization.' It adds a distinctive behavior (linking with an existing email instead of duplicating), which clearly differentiates it from siblings like client_update or client_list. The purpose is unambiguous and contextually rich.

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

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

The description implies when to use the tool (when creating a client) and hints at the de-duplication benefit, but it does not explicitly state when to prefer this over alternatives or mention any exclusions. It provides no direct comparison with sibling tools like client_update or cierre_crear_cliente. This is acceptable but minimal.

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

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

With no annotations, the description carries the burden of disclosing behavior. The verb 'Get' implies a read-only operation, and it states what is included in the response (financial summary, recent sessions). However, it does not mention authentication requirements, potential errors, or the effect of optional parameters like includeHistory and includeFinancials.

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

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

The description is a single sentence that is direct and front-loaded with the primary action. Every word contributes meaning, with no redundant or filler content.

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

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

For a read operation with 5 parameters and no output schema, the description provides the core purpose and key response components, but it lacks detail on parameter behavior, return format, or edge cases. It is adequate for a simple get but leaves some gaps given the missing annotations and schema 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?

The input schema has no parameter descriptions (0% coverage), so the description must compensate. It partially does by mentioning financial summary and recent sessions, which likely correspond to includeFinancials and includeHistory, but it does not explain any other parameters (orgSlug, clientId, apiKey) or clarify how the booleans control the response.

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

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

The description clearly states the verb 'Get' and resource 'client', and specifies the scope: complete details including financial summary and recent sessions. This distinguishes it from siblings like client_list (which lists clients) and client_update (which modifies clients).

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

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

The description implies usage for fetching a single client's detailed information, but it does not explicitly mention when to use this tool versus alternatives like client_list or finance_client_balance. No exclusions or alternative references are provided, so guidance is only implicit.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It mentions search and pagination but does not describe response format, cursor-based pagination mechanics, authentication via apiKey, or any side effects, leaving significant behavioral traits undisclosed.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core function and key features. There is no filler or redundant information, making it appropriately concise and well-structured.

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

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

Given 7 parameters and no annotations or output schema, the description is too brief to cover essential context such as the required orgSlug, pagination mechanics, and authentication. It provides only a high-level overview, which is insufficient for an agent to invoke the tool reliably across varied scenarios.

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

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

The input schema has no descriptions for any of the 7 parameters, so the description must compensate. It explains that 'provider' and 'outstanding debt' are filters, but it does not explain the semantics of apiKey, cursor, limit, or orgSlug, leaving a substantial gap in parameter understanding.

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 that the tool lists clients of an organization and mentions search, pagination, and filters. It uses a specific verb 'List' and specifies the resource 'clients', but it does not explicitly distinguish itself from sibling tools like client_get or cierre_listar_clientes, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or conditions that would help an agent decide between this and other client-related tools, leaving usage entirely implied by the tool name.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key constraint (email cannot be changed) but does not specify whether updates are partial or full replacements, required permissions, reversibility, or return format. Some value is added, but significant behavioral details are missing.

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

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

The description is exactly two sentences: the first states the action, the second adds a constraint. There is zero fluff and the key information is front-loaded. It earns a high score for conciseness.

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

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

For an update tool with 11 parameters, no output schema, and no annotations, the description is severely incomplete. It only provides the intent and one limitation, leaving parameter semantics, update behavior, and usage context uncovered. This is insufficient for an agent to invoke it confidently.

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

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

Schema description coverage is 0%, and the description provides no explanation for any of the 11 parameters. 'Personal data' is too generic to explain fields like rut, comuna, or direccion. The mention of email is not even a parameter in the schema, adding confusion rather than clarity.

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 ('Update an existing client's personal data') with a specific verb and resource. It distinguishes from sibling tools like client_create (new clients) and client_get (retrieval). The additional note about email not being changeable adds useful scope.

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

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

The description implies when to use the tool (updating existing clients) and explicitly excludes email changes. It does not name alternative tools, but 'existing' suggests using client_create for new clients. This is clear context but lacks explicit 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?

With no annotations provided, the description carries full responsibility and does an excellent job: it discloses variable substitution support, UTM auto-tagging on send, automatic legal footer with unsubscribe link, return values (campaign ID and recipient count), draft status, and the requirement of confirm: true. These are meaningful behavioral details beyond a simple 'create'.

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 well-structured: purpose, variable substitution, audience selection, send-time side effects, output, workflow, and confirmation requirement. Each sentence adds valuable information; no fluff 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?

Given the tool's complexity (10 params, nested adHocFilters, no annotations/output schema), the description covers a lot: audience types, UTM behavior, return values, and the draft workflow. Gaps remain for orgSlug and emailSubject, and the type parameter's interaction with the 'email campaign' description is not addressed, so it's not fully complete but is very usable.

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 description adds substantial meaning beyond the bare schema: it explains audienceType/audienceId combinations, emailBody as HTML, the confirm flag, and name's role in generating the UTM slug. However, it omits orgSlug (a required param), emailSubject, type, and apiKey. With schema description coverage at 0%, the description partially compensates but leaves some parameters unexplained.

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

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

The description opens with a clear action and resource: 'Create a new email campaign with HTML body to send to a segmented audience.' It also distinguishes itself from the sibling comms_send_campaign by noting the campaign starts as a draft, making the purpose unambiguous.

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

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

Explicitly instructs to use comms_send_campaign after creation ('Campaign starts as draft — use comms_send_campaign to execute') and provides detailed audience selection instructions (predefined vs adhoc, specific audienceId values). This gives clear when-to-use guidance and names the alternative.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the optional delivery logs per recipient, which is a useful behavioral trait, but it does not disclose whether logs are included by default, what the response format looks like, error handling, or any side effects. For a tool with no annotations, this is insufficient transparency.

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

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

The description is a single, focused sentence of moderate length. It front-loads the verb and resource, and the optional-logs clause adds relevant context without unnecessary detail. Every word contributes meaning, making it highly concise and well-structured.

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

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

The tool has 5 parameters and no output schema, so the description should provide more context about what 'details' includes, whether logs are returned by default, and how includeLogs and logLimit interact. The description is adequate for a simple get-details tool but leaves several important aspects unaddressed, making it complete only at a basic level.

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

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

The schema description coverage is 0%, so the description must compensate. It partially addresses the log-related parameters (includeLogs, logLimit) by mentioning 'optional delivery logs per recipient,' but it doesn't explain what logLimit does or how includeLogs controls the logs. Required parameters like orgSlug and campaignId are self-explanatory from their names, but the description adds little semantic value beyond the schema.

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

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

The description clearly states the tool's purpose: 'Get details of a specific campaign with optional delivery logs per recipient.' The verb 'Get' is specific, and the resource is identified as a specific campaign, which distinguishes it from sibling tools like comms_list_campaigns (list) and comms_send_campaign (send). This makes the purpose unambiguous.

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

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

The description implies the tool should be used when a user needs details of a single campaign, as opposed to listing campaigns. The context is clear, but there are no explicit exclusions or alternative recommendations. Still, the phrasing 'specific campaign' provides enough contextual guidance for typical use cases.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not explicitly state that this is a read-only operation, nor does it mention authentication requirements, rate limits, or potential side effects. It adds some context about what preferences are included, but does not disclose enough for an agent to understand the tool's behavior safely.

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

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

The description is a single, well-structured sentence that front-loads the action and resource. It is concise and every word adds meaning, with no 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?

Given the lack of annotations, output schema, and detailed parameter docs, the description must compensate by explaining return values, parameter usage, and tool behavior. It does none of this, only stating the basic purpose. For a simple getter it might be minimally acceptable, but it falls short of being complete.

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

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

The input schema has 0% description coverage, and the description does not explain the parameters. While 'orgSlug' is somewhat self-explanatory, 'apiKey' is not described, and there is no guidance on how the parameters relate to the operation. The description adds minimal value beyond the bare schema.

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

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

The description clearly states the verb 'Get', the resource 'communication preferences', and the scope 'for an organization'. It also specifies the content areas (WhatsApp, email, confirmation, reminder channels and messages), which distinguishes it from sibling tools like comms_update_preferences or comms_get_campaign.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no context about typical workflows (e.g., retrieving settings before updating them). It is a simple getter, but the lack of any usage direction makes it less helpful for an AI agent deciding between tools.

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

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

With no annotations, the description carries the burden. It states the tool is read-only and explains the effect of both optional flags (resolving match counts, including predefined segments). Missing details like pagination or error behavior, but for a list tool this is adequate.

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

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

Three sentences, front-loaded with the main purpose, followed by flag explanations and usage guidance. No wasted words; every sentence adds value.

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

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

Despite no output schema, the description specifies what each audience includes (filter definition, campaign-usage count) and what the includeCount flag adds. It could mention ordering or pagination, but it's reasonably complete for a list tool with 4 params and no 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?

The schema has 0% coverage and the description explains includeCount and includePredefined, but does not explain orgSlug (required) or apiKey. Since these are likely common context parameters, some clarity is missing; the description compensates only partially.

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

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

The description clearly states the verb (List) and the resource (saved audiences/segments used for campaign targeting), and adds specifics like filter definition and campaign-usage count. It distinguishes from sibling tools like comms_list_campaigns by focusing on audiences/segments.

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 says 'use before comms_create_campaign to pick a target audience', providing a concrete usage context and linking to a sibling tool. Also explains when to set includeCount and includePredefined flags.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It only states 'List' and 'Filter by status', but does not mention pagination (cursor/limit), authentication (apiKey), the required orgSlug, or any side effects. The read-only nature is implied by 'List' but not explicitly stated, and no other behavioral traits are disclosed.

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, front-loaded sentences with no wasted words. It effectively communicates the core action and a key filter option.

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 5 parameters, no output schema, and no annotations, the minimal description is not complete. It omits critical details like pagination behavior, response format, required fields, and authentication, making it difficult for an agent to use correctly without additional inference.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains the 'status' parameter via 'Filter by status', leaving limit, cursor, apiKey, and orgSlug entirely unexplained. This is insufficient for a 5-parameter tool.

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

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

The description clearly states the tool lists communication campaigns (WhatsApp/email) for the organization, using a specific verb 'List' and a resource. This distinguishes it from siblings like comms_get_campaign (single campaign), comms_create_campaign, and comms_send_campaign.

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 one needs to list campaigns and mentions filter by status, but it does not explicitly state when to use this tool over alternatives or provide exclusion criteria. No alternatives are named, leaving the guidance implicit.

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

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

No annotations are provided, so the description carries the burden. It discloses PNG rendering and the WhatsApp send side effect. However, it omits the 'upload' action entirely, does not mention authentication requirements, and does not describe the response format or consequences of sending.

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 the tool's purpose, and no fluff. The template list and action guidance are packed into compact, useful phrasing.

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

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

Given the tool's complexity (9 params, nested data object, no output schema, no annotations) the description covers core behavior and send side effects but leaves notable gaps: the 'upload' action, response/return details, and several parameter semantics. It is adequate for basic use but not fully self-sufficient.

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

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

Schema description coverage is 0%, and the description compensates partially by listing template values and example data fields ('clientName, providerName, date, time'). Yet it leaves several parameters unexplained: apiKey, orgSlug, width, clientId, whatsappTo, and whatsappBody.

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

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

The description opens with a specific verb and resource: 'Render a communication template as a visual image (PNG)'. It lists the three available templates and distinguishes itself from sibling comms_send_message by emphasizing image rendering and WhatsApp attachment behavior.

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 actionable usage instructions: 'Use action "preview" to get the image URL, "send" to render and send via WhatsApp with the image attached.' This gives clear context on how to use the two main actions, though it does not mention the 'upload' action or explicitly contrast with comms_send_message for non-image sends.

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

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

With no annotations, the description carries the full burden and does so excellently. It discloses asynchronous sending, immediate return, recipient skipping for opt-out/bounce (with 'skipped' logging), and tracking via provider webhooks. This gives a clear picture of side effects and timeout behavior.

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

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

The description is three sentences, each earning its place: the action, the side effects/skipping behavior, and the status/confirmation/tracking guidance. It is front-loaded with the core purpose and contains no 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?

Given the tool's moderate complexity and lack of output schema/annotations, the description is remarkably complete. It covers prerequisites (draft/scheduled status), behavioral side effects (asynchronous, skip logic), required confirmation, and post-invocation tracking via a sibling tool. An agent has enough context to invoke correctly and know what to expect.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the critical requirement 'Requires confirm: true', which the schema alone does not convey. However, orgSlug, campaignId, and apiKey are left to self-explanatory names, and the description doesn't elaborate on them further. The confirm requirement adds meaningful value, but overall parameter semantics are only partially compensated.

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 'Execute a draft or scheduled campaign' and 'Sends messages to all matching recipients asynchronously', which is a specific verb+resource scope. It distinguishes from siblings like comms_get_campaign and comms_send_message by focusing on bulk campaign execution and explicitly referencing comms_get_campaign for tracking.

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 usage context: 'Campaign must be in draft or scheduled status' and 'Requires confirm: true'. It explicitly names comms_get_campaign as the tool for tracking progress, serving as an alternative. It doesn't explicitly state when not to use it, but the constraints are clear enough for an agent to decide.

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

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

With no annotations, the description must disclose behavioral traits itself. It does mention 'Requires confirm: true' as a safety mechanism, and the template/custom distinction offers some insight into input behavior. However, it omits critical details such as whether the send is immediate, irreversible, what the response looks like, or any rate limits or permission requirements. Major gaps remain.

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 three sentences long, concise, and front-loaded with the core purpose. The 'Requires confirm: true.' sentence is slightly abrupt but effectively highlights a key constraint. No wasted words, though it could be slightly more structured.

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

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

For a tool with 8 parameters and no output schema, annotations, or return-value documentation, the description is incomplete. It does not explain the role of variables, the exact effect of sending, potential errors, or the response format. It provides the essential action but leaves the agent without enough operational context for safe and 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 coverage is 0%, so the description must compensate. It explains templateKey, customMessage, and confirm, but leaves apiKey, orgSlug, clientId, variables, and channel unexplained. Variables is particularly important for template usage, and its absence is a significant gap. The description only covers a minority of the parameters.

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

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

The description clearly states the tool's function: 'Send a single WhatsApp or email message to a specific client.' The verb is specific ('send'), the resource is explicit ('message'), and the scope ('single', 'specific client') distinguishes it from sibling tools like comms_send_campaign and comms_render_message.

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 guidance on how to choose content: 'Use templateKey for predefined templates or customMessage for free text.' This implies when to use the tool (one-off direct messaging) and how to construct the content, though it does not explicitly name alternative tools or state when not to use it.

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

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

No annotations are present, so the description carries the transparency burden. It discloses two important behaviors: partial update ('only provided fields are changed') and upsert behavior ('Creates preferences if none exist'), which go beyond a generic 'update.' It does not mention auth requirements, return value, or error conditions, but the core side effects are clearly stated.

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

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

The description is two sentences, starts with an action verb, and contains no filler. Every clause earns its place by adding either purpose, behavior, or upsert semantics.

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

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

For a tool with 12 parameters and no output schema, the description is too sparse. It omits return value, required authentication (apiKey), and parameter-specific details, so an agent cannot fully predict the result or formulate the call without additional inference from property names.

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 12 parameters and 0% schema description coverage, the description needed to compensate, but it only describes the overall effect ('Enable or disable communication channels') and the partial-update rule. It does not explain individual parameters such as apiKey, orgSlug, phoneRequiredMessage, or the various confirmation/reminder flags, leaving the agent to infer from property names.

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

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

The description opens with the specific verb 'Enable or disable' and identifies the resource as 'communication channels and features for an organization.' It also distinguishes this mutation from retrieval/send siblings by stating 'Partial update' and 'Creates preferences if none exist,' making the purpose unambiguous.

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

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

The description implies the tool is for updating organizational communication preferences, and the partial-update/upsert details provide context for invocation. However, it does not explicitly name alternatives or state when not to use it (e.g., versus comms_get_preferences or comms_send_message), so guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden. It discloses the privacy behavior (returns only flags/timestamps and hasEvidence, never evidence summary content) and explains the auto-confirmation behavior. However, it omits pagination, error handling, and authentication requirements.

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

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

The description is a single, information-dense sentence that front-loads the purpose and includes state definitions and privacy note. It is efficient but somewhat long; a more concise structure would improve readability without losing content.

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

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

The description covers purpose, state semantics, and privacy, which is strong for a tool with no output schema or annotations. However, it lacks details on pagination behavior and authentication, which are relevant for a list endpoint.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for 'state' (defines each enum value) and 'sessionId' (lookup), but does not explain page, limit, apiKey, or orgSlug beyond their generic role. This partial coverage is insufficient for a 0% schema coverage.

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

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

The description clearly states the tool lists the delivery-confirmation ledger for an organization's sessions, with a specific resource ('DeliveryProof overlay') and verb ('List'). It distinguishes itself from sibling confirmations tools by detailing the three-state model and session lookup.

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 usage context: filter by state or look up by sessionId. It does not explicitly name alternatives or when not to use it, but the guidance is unambiguous for the intended scenarios.

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

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

No annotations are present, so the description carries the full burden. It discloses that filtering by status/type is supported and that client/provider info is returned. However, it does not mention pagination, ordering, authentication requirements, or potential edge cases, which are important for a list tool.

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

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

The description is only two sentences, front-loading the primary action ('List disputes') and adding essential details about filtering and return content. There is no unnecessary verbosity.

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 6 parameters, no output schema, and no annotations, the description is incomplete. It does not clarify pagination, required authentication parameters, or the meaning of filter values, leaving significant gaps for an agent invoking the 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%, so the description must compensate. It only explains the 'status' and 'type' filter parameters, leaving 'page', 'limit', 'apiKey', and 'orgSlug' without meaningful explanation. This partial coverage is insufficient for a 6-parameter tool.

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

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

The description clearly states 'List disputes for an organization' and specifies the filtering options and the returned data (client and provider info). This makes it unambiguous and distinguishes it from sibling list tools.

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

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

The description implies usage through its action statement but does not provide explicit when-to-use or exclusions relative to alternatives. There are no sibling dispute-specific tools, so the intended use is reasonably clear, but explicit guidance is missing.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does disclose a key behavior: the partial-update semantics ('rest stays unchanged'). However, it does not mention auth requirements, reversibility, side effects on existing configuration, or error behavior. This is a mutation tool, so more transparency would be beneficial, but the partial-update disclosure adds meaningful value.

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 concise (two sentences), front-loaded with the primary purpose, and every sentence contributes information. It avoids fluff and gets straight to the point while including the important partial-update 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?

This is a configuration tool with 5 parameters, one being a nested array of objects, and no output schema. The description does not explain the steps array structure, what blockOnStep5 or gracePeriodDays control, or what happens after the update. It is minimally viable but insufficient for an agent to confidently invoke the tool with correct nested data.

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

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

Schema description coverage is 0%, so the description must compensate. It adds optionality information ('All fields except organizationSlug are optional') but does not explain the meaning of the 'steps' array, its nested structure (step, channel, daysAfterDue), or the purpose of 'blockOnStep5' and 'gracePeriodDays'. The schema names provide some hints, but the description fails to clarify the expected format for a complex nested parameter.

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

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

The description clearly states the tool's function: 'Update dunning (payment recovery) configuration for an organization.' It uses a specific verb ('Update') and resource ('dunning configuration'), and clarifies the domain term 'dunning' as 'payment recovery'. It also distinguishes itself from the sibling tool 'dunning_get_config' by contrasting update vs. get operations.

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 explicit usage guidance: 'All fields except organizationSlug are optional — only provided fields are updated, rest stays unchanged.' This tells the agent when to use it (partial updates) and clarifies that not all fields need to be supplied. However, it does not explicitly mention alternatives or when not to use it, such as referencing dunning_get_config for reading current configuration.

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

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

With no annotations, the description carries the safety burden. It discloses that the tool returns configuration details but doesn't cover permission requirements, error conditions, or the fact that it's a read-only operation beyond the verb 'Get'.

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

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

Two sentences, front-loaded with the action and resource, then a list of returned fields. No filler words.

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

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

The tool has no output schema, so the description should provide a fuller picture, including parameter semantics and potential errors. The description covers the return content but is incomplete for safe invocation, especially without 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 0% and the description does not mention apiKey or organizationSlug. The only hint is 'for an organization,' which clues in organizationSlug but leaves apiKey completely unexplained, forcing the agent to guess its purpose.

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

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

The description uses the specific verb 'Get' and names the resource 'dunning configuration' scoped to an organization, listing key output fields (enabled, grace period, step timings, blocking settings). This clearly distinguishes it from the sibling dunning_configure 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?

The description provides clear context: use when you need to read current dunning settings. It doesn't explicitly mention when not to use it or point to dunning_configure for updates, but the wording implies this is the read-only counterpart.

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

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

No annotations are provided, so the description carries the full burden. It provides concrete behavioral details: deletes from both Resend and the database, reverts to the default address, and requires confirm:true. This goes beyond a generic delete description. It does not mention irreversibility or permission requirements, but the information given is solid. Score 4, not 5, because it omits consequences like whether the action is irreversible and potential edge cases (e.g., if the domain is already the default).

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 three sentences long, front-loads the action ('Remove...'), and contains no filler. Every sentence earns its place: the first states the core purpose, the second explains the scope of deletion, the third gives the fallback and confirmation requirement. It is appropriately sized for a simple delete tool.

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

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

The tool has no output schema and 0% schema description coverage, so the description needs to provide enough context. It explains the main behavioral consequences (dual deletion, fallback) but does not mention return values, error handling (e.g., what happens if domain is not found), or the role of 'apiKey'. While the deletion result is likely a success message, the description could be more complete. Score 3 reflects moderate completeness.

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

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

The description refers to 'confirm: true' and implies that orgSlug identifies the organization, but it does not explain the role of orgSlug in the deletion or what apiKey is used for. With schema description coverage at 0%, the description should have compensated by explaining each parameter. It only partially addresses the required parameter 'confirm', leaving the other two parameters unexplained. This fails to provide sufficient meaning beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Remove the configured email sending domain from the organization.' This is a specific verb (remove) and resource (email domain), and it distinguishes from siblings like email_domain_get, email_domain_register, and email_domain_verify by describing a deletion action. The wording is unambiguous and action-oriented.

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 (to remove an email sending domain) and clarifies the fallback behavior ('revert to using the default Coordinalo sending address'). However, it does not explicitly name alternatives or state when not to use it, so it meets the 'clear context' level but lacks explicit exclusions or alternative mentions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that the tool returns null if no domain is configured and lists the possible verification statuses (PENDING, VERIFIED, FAILED). However, it does not explicitly confirm that the operation is read-only, though 'Get' strongly implies this.

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 three sentences long, front-loaded with the main purpose, then adds the null-return behavior and an alternative tool reference. Every sentence adds value, and there is 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?

The description is complete for a simple get tool: it covers what is retrieved, the return value in the absence of a configured domain, and directs users to a related tool. It does not explain the return format in detail, but since there is no output schema, the mention of verification status is helpful. Missing details like authentication are generic and not critical here.

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

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

The schema has no descriptions for parameters (0% coverage), so the description must compensate. It mentions that the tool works 'for an organization', which partially maps to the required orgSlug, but it does not explain the apiKey parameter or clarify how to pass the orgSlug. This leaves the parameter semantics incomplete.

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: to retrieve the email sending domain configured for an organization and its verification status. It uses a specific verb ('Get') and resource (email sending domain), and distinguishes itself from sibling tools like email_domain_register and email_domain_verify.

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 for when to use this tool (to fetch domain configuration and status) and points to an alternative (email_domain_register) for setting one up. It does not explicitly mention when not to use it, but the guidance given is sufficient for basic differentiation.

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

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

With no annotations provided, the description carries the full burden. It discloses a critical behavioral trait: 'Replaces any previously configured domain,' and also explains that DNS records are returned for external configuration. It does not mention authentication requirements or rate limits, but the disclosed side effects and follow-up step provide solid transparency beyond the raw schema.

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

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

The description is three sentences long, with each sentence adding value: the registration action, the DNS records requirement, and the replacement warning plus verification step. It is front-loaded with the purpose and avoids 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 tool with no output schema, the description explains the return value ('Returns DNS records') and the essential workflow. It also highlights the destructive replacement behavior and directs users to the verification tool. It could elaborate on the DNS record structure or prerequisites, but it is sufficiently complete for a straightforward registration tool.

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

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

The schema has 0% description coverage for its 3 parameters (apiKey, domain, orgSlug), and the description adds no information about them. It does not explain the meaning, format, or purpose of any parameter. The description mentions 'domain' and 'organization' only indirectly via prose, but fails to compensate for the complete lack of schema-level 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 clearly states the tool's function with a specific verb ('Register'), a resource ('custom email sending domain'), and a scope ('for an organization via Resend'). It distinguishes itself from sibling tools like email_domain_delete, email_domain_get, and email_domain_verify by focusing on the registration action.

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

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

The description provides a clear workflow: register, configure DNS records, then verify with email_domain_verify. It also warns that the tool 'Replaces any previously configured domain,' which is an important usage consideration. However, it does not explicitly mention alternatives for getting or deleting domains, but the verification pointer is strong.

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

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

With no annotations, the description carries full burden. It discloses the side effect ('Trigger DNS verification') and explains possible outcomes: VERIFIED, PENDING, FAILED, including their meanings. This gives a clear picture of what the tool does and what to expect, although it doesn't discuss auth requirements or idempotency.

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, each earning its place: purpose, when to call, and possible statuses. Front-loaded with the action, no filler.

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

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

For a simple tool with two parameters and no output schema, the description covers the core aspects: purpose, timed usage, and return statuses. It could mention prerequisites like prior registration, but overall it's sufficiently complete for an agent to invoke correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain apiKey or orgSlug beyond what their names imply. While orgSlug is somewhat self-explanatory, the lack of any parameter detail fails to add value over the raw schema.

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

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

The description clearly states a specific action: 'Trigger DNS verification for the configured email domain'. It distinguishes this tool from siblings like email_domain_get, email_domain_register, and email_domain_delete by using the verb 'verify' and describing the verification process.

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 explicit timing: 'Call this after the organization has added the required DNS records.' This tells the agent when to invoke the tool. It does not explicitly mention alternatives, but the sibling names make alternatives apparent, and the 'after adding DNS records' context is clear enough for correct usage.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's output structure (pending charges grouped by age buckets) but does not clarify read-only safety, return format, or pagination behavior. This is adequate for a read-only report but lacks explicit behavioral safeguards or side-effect disclosure.

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

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

The description is two sentences, front-loaded with the core action and resource, then provides bucket details and usage context. Every sentence adds value, and there is no redundancy.

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

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

The tool has 4 parameters, no annotations, and no output schema. The description explains what the report contains but omits pagination behavior, return structure details, and parameter semantics. This is minimally adequate for a simple report tool, but not fully complete.

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

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

Schema description coverage is 0%, and the description does not explain any of the parameters (orgSlug, limit, apiKey, cursor). The schema provides names and types, but the agent must infer their meaning. The description adds no value beyond the schema for parameter understanding, so a low score is warranted.

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

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

The description uses a specific verb ('Get') and names a clear resource ('accounts receivable aging report'), and it details the age buckets (0-7, 7-30, 30-90, 90+ days). This distinguishes it from sibling tools like finance_client_balance or finance_list_invoices, which are not aging-specific.

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

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

The description explicitly states when to use the tool: 'Use to answer "who owes money" or "old debts" questions.' It provides a clear context without naming alternatives, which would merit a 5, but it still gives actionable guidance.

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

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

With no annotations provided, the description carries the burden. It discloses the components of the balance but does not state that the operation is read-only, require permissions, or describe return format or edge cases. It adds some context beyond the name but lacks depth for full behavioral transparency.

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

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

A single sentence that front-loads the core action and lists key outputs. No redundant information or filler. Every word earns its place.

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

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

Given no output schema and no annotations, the description is somewhat under-specified. It defines the purpose and balance components but does not mention parameter details, return structure, or any usage caveats. For a simple getter, it is minimally viable but not complete enough for an agent to fully predict behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'client', which maps to clientId, but does not explain orgSlug or apiKey. The parameter names are self-explanatory to a degree, but the description adds minimal value beyond the schema, failing to fully compensate for the lack of 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's purpose with a specific verb ('Get') and resource ('complete financial balance for a client'), and enumerates the components (sales, charges, payments, pending debt, credits). It is specific enough to distinguish from sibling finance tools like finance_aging or finance_list_payments.

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

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

The description implies usage when a client's overall financial balance is needed, but it does not explicitly state when to use this tool over alternatives (e.g., finance_list_payments for just payments) or mention any exclusions. This is clear context without explicit guidance, so it falls at 'implied usage'.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds the requirement that 'confirm' must be true and clarifies that the charge is not linked to a sale. However, it omits other behavioral aspects such as side effects on client balances, idempotency, or authentication requirements, leaving significant ambiguity for a financial write operation.

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

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

The description is three short sentences, front-loaded with the primary action, followed by a key differentiator and a required flag. Every sentence contributes information with no wasted words.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description provides only minimal guidance. It lacks information about return values, error conditions, prerequisites, or the meaning of optional fields, making it incomplete for a complex financial operation.

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

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

The schema has 9 parameters with 0% coverage from descriptions. The description only addresses 'confirm' (requires true), leaving orgSlug, clientId, monto, descripcion, and others unexplained. Field names provide some hints but are insufficient for an agent to construct valid calls, especially for optional parameters like tipo, fecha, apiKey, and idempotencyKey.

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

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

The description uses a specific verb 'Create' and identifies the resource as a 'manual charge (cobro) for a client.' It further distinguishes from sale-linked transactions by stating 'Not linked to a sale/venta,' which clearly differentiates it from finance_create_venta and other billing 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 provides usage context by clarifying this tool is for manual charges not linked to sales, which helps select among finance_create_venta and other billing tools. However, it does not explicitly name alternative tools or mention when not to use it beyond the sale exclusion, so it lacks explicit exclusions.

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