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

With no annotations, the description must disclose behavior itself; it does say the tool completes the current step, moves currentStepId, and validates phase transitions, which signals a mutating operation with validation. However, it does not mention failure behavior on invalid transitions, permissions, or potential side effects, leaving some behavioral gaps.

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

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

Two short sentences contain the action, mechanism, and a validation constraint with no filler or repetition. The key behavior is front-loaded.

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

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

For a simple 2-parameter mutation with no annotations or output schema, the description covers the main flow and validation but omits error handling, return details, and prerequisites. It is adequate but not complete enough to fully guide an agent without additional assumptions.

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

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

The schema describes stepId's optional/default behavior, and the description reinforces that context by mentioning 'current step' and 'specific step id'. The requestId parameter is only derivable from 'for a request', not explicitly described, so with 50% schema coverage the description only partially compensates.

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

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

The description states a specific action (advance), a clear resource (current step for a request), and the outcome (completes current step and moves currentStepId). This distinguishes it from sibling tools like list_request_steps or update_request_status, which handle viewing or status changes rather than step progression.

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

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

The description clearly implies the tool is used when a request's step should be moved forward, but it does not explicitly state when not to use it or name alternatives such as update_request_status or list_request_steps. Context is clear, yet exclusions and alternative routing are absent.

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 of behavioral disclosure. It explicitly states that it creates an external Teams meeting via Graph and sends invites immediately, which are important side effects. It does not cover auth or error details, but the key behavioral consequences 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 a compact, front-loaded two-sentence definition with no filler. Every clause adds meaning: parameters, optionality, external creation, and immediate invites.

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 7 parameters, no output schema, and no annotations, the description gives the essential call shape and the major side effects, but it leaves gaps around return value, invite defaults, and the meaning of serviceRequestId. It is adequate but not fully complete.

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

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

Schema description coverage is low (29%), and the description partially compensates by naming title, scheduledAt, duration, optional serviceRequestId, and invite selection. However, it omits the 'description' parameter and does not clarify how serviceRequestId affects the meeting or what the invite flag defaults are.

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-resource pair ('Create a meeting'), lists the core parameters, and notes the external Teams/Graph integration. This clearly distinguishes it from sibling tools such as list_meetings and respond_to_meeting.

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 frames the tool as the meeting-creation entry point, including immediate invite sending, which differentiates it from list_meetings and respond_to_meeting. It does not name alternatives or describe when not to use it, but the context is sufficiently clear for selection.

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

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

With no annotations, the description carries the behavioral burden. It clearly indicates the operation is a creation and that answers must match the service formConfig, which suggests validation behavior. However, it does not disclose return values, error behavior, permission requirements, or side effects beyond creating the request.

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 long, front-loads the main purpose, and avoids repeating schema details. Every sentence contributes essential information about what the tool does and what it requires.

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?

Schema coverage is complete and the description covers the core prerequisite, but there is no output schema and no mention of what the tool returns or how failures occur. Given the tool has nested answers and multiple sibling lookup/creation tools, a bit more context about the expected result would make it fully complete.

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

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

The input schema already documents all three parameters with clear descriptions, including 'Service id or slug' and 'Form answers keyed by field name'. The description adds modest value by emphasizing that answers must match formConfig, but most parameter meaning is already covered by the schema, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Create' and the resource 'service request', and is distinct from sibling tools like create_meeting and list_service_requests. It also clarifies the key requirement (serviceId or slug plus answers), leaving no ambiguity about what the tool does.

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

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

The description implies the tool is used when creating a service request and mentions the needed serviceId or slug, but it does not explicitly contrast with siblings such as list_services or get_service. There is no when-not-to-use guidance or routing to an alternative, so usage context is only implicitly present.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds value by stating that it returns verification status and warns against trusting redirects alone, which is a meaningful behavioral trait beyond the tool name. It could say more about response shape or errors, but for a simple read operation it is reasonably transparent.

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

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

Two concise sentences with no fluff. The core action and resource are front-loaded, the return fields are compactly listed, and the important caveat about redirects is included without overexplaining.

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

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

For a single-parameter read tool with no output schema, the description covers what is returned (payment row fields and verification status) and gives a critical usage warning. It does not enumerate possible status values or error conditions, but the tool is simple enough that the description is largely sufficient.

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

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

The schema already covers the single parameter requestId with 100% description coverage, so the baseline is 3. The tool description adds no new parameter-specific details, but the parenthetical mention of serviceRequestId being unique provides minor contextual reinforcement.

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

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

The description clearly states the action (get) and resource (payment state/status for a service request), and lists the relevant fields. It does not explicitly differentiate from the sibling verify_payment, though the resource focus is reasonably distinct.

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

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

The warning 'never trust redirect alone' implies this tool should be used when authoritative verification is needed, rather than relying on redirects. However, it does not explicitly name alternatives or state when not to use this tool, so guidance remains implied.

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

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

No annotations are provided, so the description carries the behavioral burden. It communicates that the operation is a retrieval ('Get') and reveals included data, but it does not explicitly state read-only behavior, error conditions, or auth requirements. This is adequate for a simple getter but leaves some traits implicit.

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

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

A single, front-loaded sentence conveys the action, target, lookup key, and return contents with no filler. Every word earns its place.

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

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

For a one-parameter retrieval with no output schema, the description adequately names the key fields returned. It does not explain the structure of formConfig or delivery steps, but that is likely acceptable for the tool's complexity; the core selection and invocation information is present.

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

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

Schema description coverage is 100% for the single parameter, and the description's 'id or slug' matches the schema exactly. The description does not add format, example, or precedence details beyond the schema, so baseline 3 is appropriate.

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

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

The description states a specific verb ('Get'), a specific resource ('a single Meridian service'), and the lookup key ('id or slug'), and it names returned content ('formConfig and delivery steps'). This clearly distinguishes it from list_services (plural) and get_service_request (a different resource type).

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

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

The description clearly implies use when a single service's full configuration is needed rather than a list. It does not explicitly name alternatives or exclusions, but 'single' and the presence of list_services provide enough contextual routing.

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. 'Get' implies a read operation, and the phrase 'including current step, phase, and requestSteps' usefully discloses response content. However, it does not mention error behavior, whether requestSteps are expanded or referenced, or any access requirements.

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

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

The description is a single front-loaded sentence with no wasted words. It states the action, resource, and key response content efficiently.

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

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

For a simple one-parameter get-by-id tool, the description provides enough information to select and invoke it. The lack of an output schema is partially mitigated by naming included fields, though response shape, error cases, and relationship to workflow-specific siblings are not addressed.

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

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

Schema description coverage is 100%, with the single 'id' parameter already documented as 'ServiceRequest id'. The description only repeats the 'by id' concept and adds no format, type, or usage nuance 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 fetches a single service request by id and specifies key returned fields (current step, phase, requestSteps). It is distinguishable from list_service_requests, though it does not explicitly contrast with siblings like get_service or get_workflow_status.

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

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

There is no explicit guidance on when to use this tool versus alternatives. An agent must infer that this is for single-record lookup rather than listing requests or checking workflow status. No conditions, exclusions, or alternative routing are mentioned.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does add useful context by explaining that status is derived from currentStepId → phase, which clarifies how the returned value is computed. But it does not disclose side-effect-free behavior, error conditions, whether the status is live-computed each call, or any rate/authorization caveats, leaving notable gaps for a read 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 a single, dense sentence that front-loads the purpose and key output fields, then adds the derivation rule as a second concise sentence. There is no filler or repetition.

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

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

For a simple one-parameter, read-style tool with full schema coverage, the description is nearly complete: it tells the agent what the tool returns and how the status is derived. Minor gap: it doesn't state that this is a safe read-only call (no annotations available) nor the meaning of the PENDING/IN_PROGRESS/COMPLETED statuses in relation to advance_step, so the agent might need to infer workflow context.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already explains requestId as 'ServiceRequest id'. The tool description adds no further meaning about this parameter (e.g., required-format, behavior if missing, or relationship to related entities), but it doesn't need to compensate for a schema gap. Baseline 3 is appropriate.

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

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

The description uses a specific verb-resource pair ('Get the workflow state') tied to a clear domain object (request steps), enumerates the returned fields (current phase, current step, all requestSteps with status), and names the derivation rule. This is fully specific and distinguishes it from the sibling tools, which concern services and request CRUD rather than workflow progress.

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 implies usage: call after a request exists, when you need workflow progress/status. It also signals a direct, simple lookup against sibling tools like update_request_status or advance_step. However, it provides no explicit when/not-to-use guidance, no prerequisites (e.g. request must exist), and no alternatives mention, so it earns only the implied-usage score.

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 to lean on, the description carries the burden. It discloses the return fields (name, slug, icon, isActive, sortOrder, countryCode), which is useful, but it does not mention ordering, filtering, pagination, or whether inactive categories are included. 'List' implies read-only behavior, but this is not 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?

One tight sentence with no wasted words. The verb/resource is front-loaded and the parenthetical field list adds meaningful detail without bloat.

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

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

For a zero-parameter listing tool with no output schema, the description is nearly complete: it names the resource and the returned fields. It could go further by stating that it returns all categories or that no input is required, but nothing critical is missing for a simple list.

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

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

There are no parameters, and the schema is an empty object, so the 100% coverage baseline applies. The description correctly needs no parameter explanation; the zero-parameter case is handled well.

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+resource pair: 'List Meridian service categories' and enumerates the exact fields returned. This clearly distinguishes it from sibling tools like list_services by naming the resource type (categories).

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

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

The intended use is implied by the resource name and listing behavior: call this when you need Meridian service categories. However, there is no explicit guidance on when to prefer this over list_services or any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'List meetings' and filters. It does not mention pagination, ordering, default visibility scope, whether filters can be combined, or any read-only guarantees. The extra sentence about meeting creation constraints adds background context but does not describe the behavior of this tool.

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

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

The description is compact and front-loads the primary action and filters. The second sentence provides relevant domain context without excessive detail, though it is not essential for invoking the list operation correctly.

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 two optional parameters and no output schema, the description gives the core filters but omits important call details like whether filters are ANDed, what the default result set is, and whether status values are exact. The unsupported userId filter is a notable completeness gap that could lead to incorrect invocation attempts.

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 filter context for serviceRequestId, which lacks a schema description, but it also introduces a 'participant userId' filter that is not present in the schema. Since schema coverage is only 50%, this mismatch fails to properly compensate for the undocumented parameter and can mislead the agent into passing an unsupported argument.

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

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

The description clearly identifies the operation as listing meetings and lists filter dimensions, which distinguishes it from sibling tools like create_meeting and respond_to_meeting. However, it advertises filtering by 'participant userId' even though no such parameter exists in the input schema, which slightly muddies the intended 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 this is the tool for listing and filtering meetings, and the sibling names make the alternative operations obvious. It does not explicitly state when to prefer this over other list tools or give exclusions, so the usage context is only implied rather than directly articulated.

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. It does convey that the operation is a list (implying non-mutating) and provides useful output details: ordering and returned fields. However, it does not mention error cases, authorization requirements, or whether the response is an array, leaving some behavioral ambiguity.

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

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

The description is one efficient, front-loaded sentence. It opens with the core action and scope, then lists the specific fields returned. Every word 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 simple one-parameter read tool with no output schema, the description is mostly complete: it specifies scope, ordering, and returned fields. It lacks explicit handling guidance for edge cases like empty results or invalid request IDs, but these are minor for this tool's simplicity.

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

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

The schema has a single requestId with 0% description coverage. The description's phrase 'for a request' vaguely ties requestId to the request being queried, which provides some meaning beyond the raw schema. Still, it does not explicitly define requestId, its format, or how it relates to other request identifiers, so it only partially compensates for the missing schema descriptions.

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

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

The description clearly states the action ('List all RequestSteps'), the target resource ('RequestSteps for a request'), and the ordering ('in order'). It distinguishes itself from sibling tools like list_service_requests, which list requests rather than individual steps, and from advance_step, which mutates a step.

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

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

No guidance is given about when to prefer this tool over siblings or when not to use it. The description only states what the tool does, leaving the agent to infer that it should be used whenever ordered request steps are needed.

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 behavioral disclosure. It only says 'List' and enumerates filters; it never states that the operation is a safe read, how filters combine (AND vs OR), behavior when no filters are passed, pagination beyond the schema's default-20 note, or any auth requirements. The verb 'list' implies read-only but nothing is made 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 sentences with the core purpose front-loaded ('List service requests') before the filter details. The status enumeration is long but earns its place because the schema provides no enum values. There is no redundant phrasing or filler.

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

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

With no output schema, no annotations, and four optional parameters, the description is thinner than the tool's complexity warrants. It omits what a returned service request item looks like, what happens with no filters (returns all?), and how this relates to get_service_request or list_request_steps. For a read tool with zero annotation coverage, an agent is left guessing about the response contract.

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 50% — limit and status have descriptions while customerId and providerId do not. The description compensates meaningfully by enumerating all 11 valid status values (which the schema lacks, as there are no enums) and by confirming customerId/providerId serve as filters. However, it adds no ID format, no semantics for how filters interact, and no guidance on limit usage beyond what the schema already says.

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+resource pair — 'List service requests' — and adds the filter scope (status, customerId, providerId), which sharpens the purpose. It does not explicitly distinguish itself from siblings like get_service_request or list_request_steps, but the resource name and plural 'list' framing make the core 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 gives no guidance on when to use this tool versus alternatives — no exclusions, no mention of get_service_request for single requests, no distinction from list_services or list_request_steps. Given the large sibling set containing several list/get tools with similar names, an agent receives no routing cues beyond the tool name itself.

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 of behavioral disclosure. It conveys that this is a read-only list operation with filters, but does not mention pagination, default result ordering, or whether filters are AND-combined. These are meaningful but not critical gaps for a simple 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?

A single, front-loaded sentence that states the action and the filter options with zero redundancy. Every word contributes to the tool's usability.

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

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

For a straightforward list tool with three optional, self-documenting parameters and no output schema, the description is sufficient for correct invocation. It could mention filter composability, but sibling context and the schema fill most 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 descriptions cover 100% of the parameters, so the baseline is 3. The description adds example country codes (TN, FR, PT) and restates the filter semantics, but provides no 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 uses a specific verb ('List') and resource ('Meridian services'), and the plural form clearly distinguishes it from get_service. The three filter dimensions are named upfront, further sharpening the tool's 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?

It clearly states the tool lists services and enumerates the available filters (category slug, active flag, country code), giving an agent concrete criteria for when to use it. It does not explicitly name alternatives or exclusions, but the context is sufficient for deciding between this and sibling list/get 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 full burden. It discloses that the tool relies on MERIDIAN_API_URL and MERIDIAN_API_KEY and that it performs a connectivity check and lists tools/resources. However, it does not explicitly state whether the operation is read-only, describe error behavior, or clarify what 'connectivity' entails beyond a basic check.

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

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

The description is a single sentence that front-loads the primary purpose, mentions the relevant environment variables in parentheses, and ends with a clear 'No params.' Every element earns its place, 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?

For a zero-parameter status tool, the description is nearly complete: it identifies the purpose, the dependencies, and what the output should include ('available tools/resources'). It does not describe the exact response format, but given the simplicity and lack of an output schema, the description is sufficient for an agent to successfully 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?

The tool has zero parameters, and the schema coverage is 100% per the empty properties object. The description explicitly confirms 'No params,' which removes any ambiguity. The baseline of 4 for a no-parameter tool applies, and no further parameter information is needed.

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

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

The description states a specific verb ('Check') and resource ('Meridian API connectivity') and adds the secondary function of listing available tools/resources. It is clearly distinguishable from the sibling tools, which perform domain operations like listing services or creating requests.

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

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

The description clearly implies this tool is for verifying API connectivity and discovering available tools/resources before using other operations. While it does not explicitly state exclusions or alternatives, no overlapping sibling exists, so the intended context is clear.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that declining records an answer rather than cancelling the meeting, but it does not explain update semantics, idempotency, permissions, or the meaning of PENDING beyond the enum.

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

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

Two short sentences with no filler; the main purpose and the critical caveat are front-loaded. Every sentence contributes information.

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

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

For a simple two-parameter tool, the description, together with the schema enum and required fields, is nearly complete. The key caveat about declining is present; only minor gaps such as PENDING semantics and return behavior remain, and no output schema exists to require more.

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 some meaning by tying response to RSVP values and clarifying the effect of DECLINED, but it does not describe the meetingId format or explain when PENDING should be used.

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

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

The description names the specific action ('Record RSVP'), the resource ('meeting'), and enumerates the valid response values. This clearly differentiates it from sibling tools like create_meeting or list_meetings by establishing it as a meeting-response tool, not a scheduling or query 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 implies the tool is for submitting a meeting invitation response and explicitly clarifies that declining does not cancel the meeting. However, it does not state when to prefer this over alternatives, how to obtain a valid meetingId, or whether the tool is also used to update an existing RSVP.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It conveys a mutation and a validity caveat, but it does not explain side effects, error behavior, permissions, idempotency, or what happens to the request's progression when status is set directly.

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

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

Two short sentences front-load the core purpose and then provide the key usage caveat. Every clause earns its place with no redundancy.

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

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

For a simple mutation tool this is minimally viable: it states purpose, usage boundary, and a precondition. However, it omits what a successful response looks like, what happens on invalid statuses, and how to discover valid target phases, so an agent may still have to infer critical details.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description adds no extra parameter-level semantics beyond warning about target-phase validity, which is only partially tied to the status 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 action ('Advance or set a request's status') with a specific resource and signal that this is a status-changing operation. It also distinguishes itself from advance_step by naming the sibling, which helps an agent avoid confusion.

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 text gives explicit routing guidance: prefer advance_step for workflow transitions and use this tool only when the target phase is known to be valid. This makes the decision boundary between siblings clear.

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

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

With no annotations, the description carries the full burden, and it delivers a key behavioral disclosure: verification is server-side and contacting the provider is necessary. The caveat about redirects being insufficient is genuinely informative beyond what the tool name suggests. Minor gaps remain, such as side effects on payment state and possible error conditions, but the core behavior is clearly 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?

Two sentences, no filler. The main action is front-loaded, and the critical caveat about redirects is included in the second sentence. Every part of the description 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?

The description is sufficient for selecting the tool and understanding its authoritative server-side nature. However, with no output schema and no annotations, the agent gets no guidance on return values, and the required requestId parameter is left unexplained. It also does not clarify when get_payment_status would be the better choice, leaving a noticeable completeness gap.

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

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

Schema coverage is only 50%: paymentId has a description, but requestId has none. The description does not explain requestId at all, nor does it clarify how the two parameters relate. It mentions provider types, which adds slight context for interpreting paymentId, but it does not compensate for the undocumented required requestId 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 verb and resource: 'Verify a payment with the provider.' It adds specific context about Flouci and Stripe, and the phrase 'Triggers server-side verification' distinguishes it from a passive status lookup. However, it does not explicitly name or contrast with the sibling get_payment_status tool, so it stops short of full 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 implies when to use the tool: when provider-side verification is needed, because 'redirect back to the portal alone is never proof of payment.' This gives useful context, but it does not explicitly state when not to use it or mention the alternative get_payment_status for local/cached status checks. The usage 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.