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

With no annotations, the description adds useful context that the call is authenticated, generally POST-only, and intended for destructive operations. However, it does not describe permissions, reversibility, side effects, or error behavior for a generic destructive-capable API 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 short and front-loads the key guidance about preferring dedicated tools and using this for rare or destructive endpoints. The phrasing is slightly telegraphic, but there is little wasted text.

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

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

For a generic API escape hatch with no output schema and no annotations, the description covers usage well but leaves gaps around return format, error handling, and safety expectations for destructive calls. The schema handles parameter structure, but the behavioral context is only partially 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 coverage is 75%, so the schema already documents most parameters. The description reinforces the POST-only nature and gives endpoint examples, but it does not add much detail about how to use the body or query 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 that this is a generic authenticated Simple API call and distinguishes it from dedicated tools. It also names destructive endpoint examples, though the resource remains broad and generic by design.

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 prefer dedicated tools when available and to use this for destructive operations and rare endpoints. It also clarifies the mostly POST-only behavior of the Simple API, giving clear selection guidance.

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

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

Annotations already declare readOnly=false, destructive=false and openWorld=true, so the 'WRITE' marker is largely redundant. The description earns credit elsewhere: it discloses the actual payload shape (RequestId, Comment) for an opaque free-form object, which the annotations cannot convey.

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, mutation intent front-loaded, payload guidance second. No filler and nothing an agent must read twice.

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 a fully open nested payload and no output schema, the description covers the essential call mechanics but omits what success looks like, whether approval is reversible, and any permission or state prerequisites. Adequate to invoke, thin on consequences.

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 reads as 100%, but the schema only describes 'order' as an unconstrained object with additionalProperties, so the structured data provides almost no field-level meaning. The description partially compensates by naming RequestId and Comment, but hedges with 'usually' and leaves the rest of the payload 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?

States a specific verb and resource ('ApproveCreditCheckOrder') and prefixes with 'WRITE', so an agent immediately knows this is the mutating counterpart to list_credit_check_orders_for_approval and decline_credit_check_order. It stops short of explicitly naming those siblings, so differentiation is inferred rather than stated.

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

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

The parenthetical 'typically from list_credit_check_orders_for_approval' gives a usable workflow hint about where the payload comes from. However it never says when to choose this over decline_credit_check_order, nor what precondition (pending approval state) must hold.

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 disclose the key side effect: the next call will require a fresh login. It does not cover whether the call errors when no session exists, whether the invalidation is server-side or local, or what the response looks like — meaningful gaps for an auth-mutating 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 short sentence with the action first and the consequence in a parenthetical. Nothing extraneous and nothing buried.

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, no-output-schema utility, the description gives the essential contract: no inputs, and a known effect on the next request. Only the failure/edge-case behavior is missing, which is minor at this 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?

Zero parameters, so the baseline is 4. The description correctly implies no inputs are required, and the schema is empty as expected.

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

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

States a specific verb (drop) and resource (cached session token), plus the observable consequence on the next call. Clear enough to distinguish it from read-only siblings like validate_session, though it never names that sibling explicitly.

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

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

The parenthetical 'forces fresh login on next call' implies the use case (resetting authentication state after a stale/expired token) but never says when to prefer this over validate_session, nor when not to use it. Usage is inferred rather than stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the 'WRITE:' prefix is largely redundant. The description does add genuinely new context — that values persist and take effect at the subscription end date — but says nothing about whether existing renew settings are replaced or merged, or about required permissions.

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

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

A single compact sentence with the operation type front-loaded. The 'WRITE:' token is redundant against the annotations, but nothing else is wasted and the key effect (applied at end date) is stated up front.

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 only two parameters and no output schema, the description covers the essential shape of the operation. However, a free-form nested fieldValues object with an open-world hint needs more guidance about where valid field names come from, which is the main missing piece for correct invocation.

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

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

Schema description coverage is 100%, with accountId described as the ALSO Cloud Account ID and fieldValues as field name → value pairs, so the schema carries the parameter burden. The description adds no detail about which field names are valid or the expected shape of the nested values object, so it does not rise above the baseline.

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

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

The description names a specific resource (subscription renewal settings) and a specific effect ('stores renew field values applied at subscription end date'), so an agent knows this writes renewal configuration rather than performing an upgrade. It does not differentiate itself from near siblings such as get_subscription_fields_for_renew or reset_default_renew_values, leaving the agent to infer the boundary.

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

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

There is no guidance on when to use this tool versus the read-side siblings (get_subscription_fields_for_renew, get_subscription_fields_for_upgrade) or the execution siblings (execute_subscription_upgrade). No prerequisites are stated, such as validating field names first via validate_subscription_fields.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false; the 'WRITE:' prefix merely restates that, which adds no information. The description does add workflow context (verify with get_companies) but omits permission requirements and what the response contains (e.g., new company ID).

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 the operation and payload front-loaded and the verification hint second. Only the redundant 'WRITE:' prefix is arguably 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?

For a create tool taking an opaque nested payload with no output schema, the description should say what identifies the created record and which fields are mandatory. Pointing at 'Simple API' and suggesting get_companies verification helps, but significant gaps remain.

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 nominally 100%, but the schema only defines companyAccount as an untyped object with additionalProperties {} and the label 'CompanyAccount payload'. The description partially compensates by naming a few fields (parent, name, address) and pointing to 'Simple API', but the ellipsis leaves required field details undocumented.

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

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

The description names a specific verb and resource (create a company) and the payload object to pass ('companyAccount'). It is clearly distinguishable from get_companies/get_company siblings, though it doesn't explicitly contrast with update_company or create_reseller.

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

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

It gives a follow-up workflow hint ('Prefer get_companies afterwards to verify') but no guidance on when to use this versus update_company, nor on prerequisites such as requiring a valid parent account. Usage is implied rather than stated.

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

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

The description states 'WRITE', which is a basic behavioral hint, but provides no further insight into constraints, error handling, or required environment setup beyond what the `openWorldHint` annotation suggests.

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

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

The description is extremely concise, using short, directive sentences. Every word serves a purpose: identifying the operation type and the required input.

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 that this is a critical write operation involving a nested payload, the definition is highly incomplete. It offers no guidance on the expected content or context of the `departmentAccount` object.

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 100% schema coverage, the schema already explains the structure of the `departmentAccount` payload. The description merely repeats that this object must be passed, providing no semantic value beyond the structure defined in 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 identifies the action ('CreateDepartment'), which satisfies the basic requirement. However, it adds no domain context regarding what a department entails, relying solely on the tool name.

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

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

There are absolutely no instructions on when to use this tool relative to its siblings, such as `update_department` or other creation tools like `create_company`.

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

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

The annotations already declare readOnlyHint=false, openWorldHint=true, and destructiveHint=false, and the description adds little beyond repeating 'WRITE'. It does not explain permissions, side effects, idempotency, or what happens to an existing reseller, so it adds minimal behavioral context.

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

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

The description is very short and front-loaded, which is good, but 'WRITE:' duplicates the annotation and 'CreateReseller' duplicates the tool name/title. It is concise but not especially information-dense.

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

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

For a create mutation with a nested object payload and no output schema, the description is too thin. Annotations cover the safety profile, but the agent still lacks payload shape, success behavior, and any creation-specific constraints.

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. The description repeats the parameter name and says to pass a resellerAccount object, but it does not clarify the nested payload fields, which remain opaque despite being a nested object 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 states the operation ('CreateReseller') and the required argument, so the basic purpose is inferable. However, it largely restates the tool name and title without explaining what creating a reseller means or how it differs from related tools like update_reseller or get_reseller.

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

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

There is no guidance on when to use this tool versus update_reseller or the get_reseller tools. 'WRITE:' hints that it is a mutation, but no prerequisites, exclusions, or alternative-selection criteria are provided.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so "WRITE:" adds nothing. Beyond that, the description says nothing about side effects, whether creation is idempotent, what happens on validation failure, or what the response contains — meaningful gaps for an open-world mutation 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?

Two short clauses, front-loaded in the right order (operation, then prerequisite). It is efficiently sized but that efficiency comes from omission rather than discipline — there is essentially no content after the verb.

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 a nested untyped payload, no output schema, and mutates state in an open-world system, yet the description provides no payload guidance and no return-value expectations. Two clauses referencing prerequisite tools do not cover what an agent needs to construct a valid SubscriptionAccount.

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 reported at 100%, so the baseline of 3 applies. However the single parameter is a nested free-form object with additionalProperties {}, and the description gives no hint at the payload's shape or required fields, so it fails to compensate for a schema that is 100% covered but substantively empty.

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?

"CreateSubscription" merely restates the tool name, and "WRITE:" only re-declares the mutation annotation already present. The description never says what a subscription is being created for, its scope, or what distinguishes it from sibling creation tools like create_company or create_reseller.

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 does give a concrete prerequisite workflow — call get_fields_for_service and validate_subscription_fields first — which is genuine routing value. But it never states when to create a new subscription versus using update_subscription, get_subscription_fields_for_upgrade, or execute_subscription_upgrade, so the boundary with siblings is left to inference.

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

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

The "WRITE:" prefix largely restates the annotations (readOnlyHint=false), so it adds no new information. With openWorldHint=true and a user-creation mutation, the description never mentions side effects (invitations, provisioning), required permissions, idempotency, or what happens on failure — the highest-value disclosures 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?

Two short sentences, front-loaded with the mutation marker and the scoping constraint. Nothing is wasted, though it is telegraphic to the point of being under-specified rather than tight.

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 open-world mutation taking an unconstrained nested object as its only argument and returning no documented output, the description says almost nothing about the payload shape or consequences. An agent could form the call but could not anticipate what it will do or return.

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

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

Schema description coverage is 100% and there is a single required parameter, so the schema already carries the contract; the description only repeats "Pass userAccount object". Given the payload is a free-form nested object (additionalProperties, no field list), the description could have named expected keys but does not.

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

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

States a clear verb and resource ("CreateUser") plus a scoping constraint ("under selected parent"), which is enough to tell it apart from update_user and create_company in the sibling list. It stops short of explaining what a "parent" is or what kind of user is created, but the core action 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?

"under selected parent" hints at a prerequisite but never states when to use this versus update_user, nor what must exist beforehand. There are no when-not conditions and no named alternative for the adjacent update path.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so most of the safety profile is covered. The description adds only the redundant 'WRITE' label and does not explain whether declining is reversible, what happens to the order afterward, or what permissions are required. With annotations present, this is a minimal behavioral contribution.

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

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

The description is two short sentences with no filler, and the 'WRITE' prefix plus action name are front-loaded. Every phrase contributes either the operation type or the source of the input.

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

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

For a single-parameter mutation with no output schema, the description covers the essential input source and operation type. It remains thin on what declining actually does to the order and whether the action can be undone, which an agent might need to act safely.

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

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

Schema description coverage is 100%, so the schema already defines the single required 'order' property as a credit check order payload. The description adds marginal value by noting the object typically comes from list_credit_check_orders_for_approval, but it does not explain the object's expected shape or required fields beyond the schema.

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

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

The description states a specific verb and resource ('Decline CreditCheckOrder') and prefixes it with 'WRITE', so the agent knows this is a state-changing operation. It implicitly separates itself from the sibling approve_credit_check_order by using the opposite action, but it does not explicitly name that sibling or clarify the approval workflow.

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 useful provenance by saying the order object typically comes from list_credit_check_orders_for_approval, which helps the agent know a likely workflow. However, it does not state when to use this tool instead of approve_credit_check_order, nor does it mention prerequisites such as whether the order must be in a pending state.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so 'WRITE:' merely restates structured data. The description adds no context about side effects, idempotency, validation behavior of the free-form field values, or what happens on an unknown action name — the traits an agent most needs for an open-world 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?

One short sentence, front-loaded with a mutation marker, so there is no waste. But the size borders on under-specification rather than genuine conciseness, and the 'WRITE:' label duplicates the readOnlyHint annotation.

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 open-world write tool with a free-form nested parameter object and no output schema, the description should explain field-value expectations, likely failure modes, and result shape. None of that is present, leaving the agent under-equipped for a non-trivial invocation.

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

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

Schema coverage is 100%, so both parameters are documented, giving a baseline of 3. However, the description adds nothing about the nested subscriptionAccount object, whose arbitrary key/value structure depends entirely on the chosen action — a point where description could have supplied real value.

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

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

States a specific verb and resource: running a named custom action on a subscription, and the 'WRITE:' prefix signals mutation. It does not distinguish itself from sibling tools such as get_account_custom_actions, which an agent might otherwise pair with it to discover valid action names.

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

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

No guidance on when to use this versus get_account_custom_actions, nor any note that valid action names should be discovered first. The agent is left to infer the read-then-write workflow entirely.

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, yet it discloses nothing about execution side effects, permissions, or whether running a report creates output artifacts. 'Run' hints at execution, but nothing about what happens on failure or whether it is idempotent is 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?

It is a single, front-loaded sentence with no filler. The problem is under-specification rather than verbosity, so it lands at a middling score.

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 two nested free-form object parameters, no annotations, and no output schema, the definition leaves an agent with no way to construct a valid call beyond the required reportName. It is materially incomplete.

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% across three parameters, including two nested open-ended objects (columns, parameters) whose structure is entirely undocumented. The description only says 'with parameters', which does not explain the columns map or the expected parameter keys, so it fails to compensate for the coverage 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 restates the name and title almost verbatim: 'ExecuteReport — run a named report with parameters.' It adds only the notion of a named report and parameters, which the schema already reveals. There is no differentiation from siblings like get_reports or get_invoice_aggregation_report.

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

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

No guidance on when to use this instead of get_reports or the various report-fetching siblings. No prerequisites, no mention of whether the report must first be retrieved, and no exclusions.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the 'WRITE:' prefix merely repeats structured data. Nothing is said about what happens to the existing subscription line, whether the change is reversible, billing/proration effects, or that purchaseOrderCommitment may be mandatory for certain target products — exactly the kind of context a mutation tool needs beyond its annotations.

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

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

It is a single front-loaded sentence with no wasted words, but for a five-parameter write operation the terseness reflects under-specification rather than economy. Structure is fine; content is thin.

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?

A mutation tool with a nested object parameter, no output schema, 60% parameter coverage, and a distinct prerequisite workflow is not adequately explained by one fragment sentence. The description leaves out the ordering relative to get_subscription_fields_for_upgrade / validate_subscription_fields and the meaning of the PO commitment flag.

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 60%, and targetProductName, targetAccountId, and the nested fieldValues object have no or minimal schema descriptions. The description names only targetProductName and gives no syntax, format, or sourcing guidance (e.g. that the fieldValues keys must match the fields returned by get_subscription_fields_for_upgrade), so it fails to compensate for the coverage 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 sentence is essentially the tool name restated: 'ExecuteSubscriptionUpgrade — provisions upgrade to targetProductName' adds only the target parameter as new information. It does not distinguish this mutating execute step from the closely related siblings get_subscription_fields_for_upgrade or get_possible_services_for_upgrade, so an agent cannot tell which stage of the workflow it belongs to from the text alone.

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

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

There is no when-to-use guidance, no prerequisite chain (e.g. whether fieldValues must first come from get_subscription_fields_for_upgrade or be validated with validate_subscription_fields), and no alternatives or exclusions. The agent must infer the entire upgrade workflow from sibling names.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description only needs to add context; it does, by disclosing the underlying GetCompanies call, the CompanyName filter behavior, and the parent-account scoping with the ALSO_CLOUD_PARENT_ACCOUNT_ID fallback. It stops short of stating match semantics (prefix vs substring) or result-count limits.

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

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

Two tight sentences; the preference statement is front-loaded and the negative routing instruction follows immediately. 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 2-parameter read tool with full schema coverage, annotations, and no output schema, the description covers purpose, scope default, and alternatives. The only real gap is expected result shape and how partial-name matching behaves, which an agent might reasonably wonder about given the 'fragment' input.

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 both parameters are already documented in the schema, including the fragment example and the env-var default. The description only restates the CompanyName filtering and parentAccountId scoping, adding no new syntax or format guidance, so baseline 3 applies.

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

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

States a specific verb and resource ('locating a company by name') and makes the preference explicit with 'PREFERRED'. It also names the concrete backend call (GetCompanies with a CompanyName filter), so an agent knows exactly what this does relative to search-style siblings.

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

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

Explicitly excludes get_reports / execute_report ('Do NOT use ... to search companies'), which is a real routing hazard. It does not, however, disambiguate against the very close sibling get_companies or get_company_by_vat_id, so the agent must infer that 'PREFERRED' means prefer this over those.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. Beyond that, the description adds only the internal method name 'WithFields', which hints that field definitions accompany each action but is never explained; there is no mention of pagination, result volume, or remote-system behavior implied by openWorldHint.

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 short sentence with the operation front-loaded and no filler. The leading internal method name is minor noise that does not crowd out the substantive 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 one-parameter, read-only list tool with no output schema and full annotation coverage, the bar is low and the description is minimally sufficient. It still leaves the agent guessing about the 'WithFields' payload shape and whether results are paginated.

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 is one parameter with 100% schema description coverage, so the schema already documents accountId as the ALSO Cloud Account ID. The description adds no further meaning about the identifier, which is the expected baseline when the schema does the work.

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

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

States a specific verb (list) and resource (custom actions) with account scoping, which distinguishes it from the sibling execute_account_custom_action that performs rather than lists. However, it says 'for a subscription' while the only parameter is accountId, introducing ambiguity about the actual scope, and it never names the execute sibling explicitly.

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

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

No guidance on when to use this versus execute_account_custom_action or the other account retrieval tools. It omits any preconditions, such as whether actions must be fetched before they can be executed.

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 — and it discloses nothing. It does not say whether results are paginated, filtered server-side, permission-gated, or what the return shape is.

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?

It is short, but this is under-specification rather than conciseness: a single restated identifier that earns no place as a description. There is no front-loaded useful information because there is no 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?

A two-parameter tool with a completely untyped 'filters' array, zero schema coverage, no annotations, and no output schema requires substantially more description than this. An agent cannot confidently construct a call from what is given.

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 for two undocumented parameters and does not. Neither 'marketplaceId' (its source or validity) nor 'filters' (an untyped array with no item schema — what filter objects are accepted?) is explained anywhere.

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 is the tool name restated in PascalCase with a period, adding no information beyond the title. The verb+resource ('get available services for marketplace') is derivable from the name itself, so the description contributes nothing. It also fails to distinguish this from the sibling 'list_marketplace_services' or 'get_possible_services_for_parent'.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. An agent has no basis for choosing this over the closely-related 'list_marketplace_services' sibling.

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 burden. It discloses the useful scope constraint that only first-level companies are returned, but it does not state read-only safety, permissions, pagination, ordering, or response shape.

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

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

The description is short and front-loaded: it names the operation and scope first, then immediately gives the alternative tool routing rule. 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?

For a simple one-parameter read/list tool with no output schema, the description is sufficient to select and invoke it correctly. It lacks return-behavior details such as pagination or ordering, but those are secondary for this tool.

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

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

Schema description coverage is 100%, so the single parentAccountId parameter is already documented. The description reinforces that it is the parent account scope but adds no syntax, format, or constraint details beyond the schema.

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

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

The description states a specific verb and resource: retrieving companies, scoped to first-level companies under parentAccountId. It also explicitly distinguishes this from find_companies for name-based search.

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

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

It gives a clear routing rule: use find_companies when searching by name. However, it does not mention other adjacent siblings such as get_company or get_company_by_vat_id, so the guidance is useful but not 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 full burden, yet it says nothing about whether the call is read-only, what happens when the accountId is unknown (empty result vs error), whether permissions are required, or what the response contains. A single short noun phrase cannot cover any of that.

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?

It is short and front-loaded with zero filler, but it is under-specified rather than truly concise — the entire definition is a fragment with no sentence that conveys actionable 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?

No output schema exists, so the description should at least sketch the returned company shape or the not-found behavior; it does neither. For a tool surrounded by many company-related siblings, missing differentiation leaves the agent to guess.

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

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

Schema description coverage is 100% and the accountId property is documented as 'ALSO Cloud Account ID'. The description only echoes the parameter name and contributes no format, range, or semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

The text 'GetCompany — company by accountId' restates the tool name and title and adds only the lookup key, which is already the sole required parameter. It never distinguishes this from close siblings such as get_companies, find_companies, or get_company_by_vat_id, so an agent cannot tell which entity shape or key each one takes.

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 statement of when to use this single-company lookup versus the plural listers (get_companies) or the alternate-key lookup (get_company_by_vat_id). Usage is only implied by the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing — not whether it is a pure read, what happens on an unknown VAT ID (error vs. empty), whether results are cached or scoped to an account, or what the response contains.

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

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

It is short, but the brevity is under-specification rather than economy: one echoed identifier earns no informational value and leaves the reader with nothing front-loaded except the name they already had.

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

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

The tool is simple (one required param, no nested objects, no output schema), so a short description could suffice — but nothing is said about lookup outcome, format expectations for the VAT ID, or failure behavior, leaving critical context entirely absent.

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

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

Schema description coverage is 100% and the single parameter vatId is documented in-schema as "VAT / UID number" with a minLength constraint. The description adds nothing beyond that, but per the high-coverage baseline a 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 is "GetCompanyByVatId." — a restatement of the tool name and title with no additional specification. It does not clarify what entity is returned, what the lookup semantics are, or how it differs from siblings such as get_company, get_companies, find_companies, or get_reseller_by_vat_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?

There is no when-to-use guidance, no exclusions, and no mention of any alternative. An agent choosing between get_company_by_vat_id, get_company, get_companies, find_companies, and get_reseller_by_vat_id gets no routing signal at all.

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. 'Get' implies a read operation, but it does not state permissions, error behavior, or what kind of credit-limit data is returned, leaving meaningful 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?

The description is a single short fragment with no filler and is front-loaded with the action. The unspaced camelCase phrasing is slightly rough, but there is no structural waste.

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

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

For a simple one-parameter getter with full schema coverage, the description gives enough to invoke the tool. However, because there is no output schema and no annotations, it should say more about the returned credit-limit information or access requirements.

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

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

Schema description coverage is 100%, and the schema already documents accountId as the 'ALSO Cloud Account ID'. The description repeats 'company accountId' but adds no format or constraint beyond the schema, so the baseline of 3 applies.

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

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

The description 'GetCreditLimit for company accountId' largely restates the tool name and title rather than adding a clearer definition of what the credit limit result represents. The phrase 'for company accountId' only echoes the required parameter and does not meaningfully distinguish it from siblings such as set_credit_limit.

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

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

There is no guidance on when to use this tool versus alternatives like set_credit_limit or the credit-check-order tools. The agent must infer that this is the read-only way to view a company's credit limit.

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 disclosure burden, yet it says nothing about read-only semantics, permission requirements, or what happens when the accountId has no department. Only the bare 'by accountId' lookup hint is offered.

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?

It is short and front-loaded, but the brevity comes from under-specification rather than efficiency: nearly every sentence slot that could carry useful information is empty.

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 lookup the bar is low, but with no annotations, no output schema, and no mention of not-found behavior or the relationship to 'get_departments', the definition leaves gaps an agent would hit immediately.

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

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

Schema description coverage is 100% and the single parameter (accountId) is documented in-schema as the ALSO Cloud Account ID. The description repeats the parameter name but adds no format or sourcing guidance beyond the schema, so the baseline of 3 applies.

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

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

The description 'GetDepartment — department by accountId' essentially restates the tool name and title, adding only the parameter name. It does not say whether this returns a single department object or clarify the scope versus the sibling 'get_departments'.

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 indication of when to use this tool rather than 'get_departments' (list) or 'get_department' vs 'get_company'/'get_reseller' lookups. The singular/plural relationship with its closest sibling is left entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond scope — no indication of whether results are paginated, whether the lookup is recursive through sub-accounts, or whether missing accounts error versus return empty. 'Get' weakly implies a read, but that is the only behavioral signal.

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?

It is one short fragment with no filler sentences, so it is easy to scan, but the 'GetDepartments —' prefix duplicates the name and title and consumes half the text without adding 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 one-parameter read tool with no output schema, the definition is minimally adequate, but it leaves open what the response contains (a list of department records?) and whether the parent scope is a strict equality filter.

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

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

Schema description coverage is 100% and there is a single required integer parameter, so the schema already documents everything. The description only echoes that parentAccountId acts as a scope filter, adding essentially no semantics 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 names the resource (departments) and a scoping constraint (under parentAccountId), which hints at a filtered listing. However, it repeats the name/title verbatim and never distinguishes itself from the sibling get_department, so an agent can't tell which one returns a collection versus a single record.

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 when-to-use guidance, no prerequisites, and no mention of alternatives like get_department or create_department/update_department. The agent must infer usage solely from the plural noun.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the prerequisite relationship to CreateSubscription / ValidateFields, but does not describe return shape, failure behavior, or any other operational detail.

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

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

The description is a single compact sentence that front-loads the purpose and use context. It has a minor redundancy in repeating the tool name as a prefix, but otherwise contains no 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 low-complexity, read-only retrieval tool with fully described parameters, the description gives enough context to invoke it correctly before create/validate flows. It does not explain the returned field-definition structure, and there is no output schema, but the broad return content is implied by the tool purpose.

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

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

Schema description coverage is 100%, so productName, parentAccountId, and secondaryParentId are already documented in the schema. The description adds no parameter-level meaning beyond that, making the baseline 3 appropriate.

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

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

States a specific verb and resource: field definitions for a service. It also ties the result to CreateSubscription / ValidateFields, which helps distinguish it from generic service-listing tools, though it does not explicitly distinguish it from sibling field-getters for upgrade/renew.

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 the tool is needed before CreateSubscription / ValidateFields, giving clear usage context. It does not name exclusions or alternatives such as get_subscription_fields_for_upgrade or get_subscription_fields_for_renew, so it falls short of a 5.

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

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

With no annotations and no output schema, the description carries the full disclosure burden, yet it says nothing about permissions, whether resellerContext changes the aggregation scope, or what the response looks like. Only the verb 'Get' implicitly signals a read operation.

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

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

It is a single short fragment, but the brevity reflects under-specification rather than economy; there is no front-loaded statement of what the tool produces.

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 three-parameter reporting tool with no annotations and no output schema, the description omits essentially everything an agent needs: report contents, period defaults, the effect of resellerContext, and the return shape.

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 33%: only resellerContext is documented in the schema. The description mentions 'year/month' but does not explain that both are optional (required list is empty), whether omitting them returns current-period data, or how resellerContext alters results.

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 restates the tool name in camel case plus a time scope ('for year/month'), which is close to tautology. It never says what an 'aggregation report' contains (totals? per-service? per-reseller?), so an agent cannot distinguish it from siblings like get_reports, execute_report, or get_latest_invoices_for_period.

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 when-to-use guidance, no when-not-to-use, and no mention of any alternative tool despite several report and invoice siblings existing. The only hint is the year/month scope, which is inferred rather than stated as a selection criterion.

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, yet it discloses nothing about behavior: no result limit/ordering, no pagination, no note that it is a read-only operation, and no mention of the reseller-context scoping implications. 'Authenticated account' implies implicit auth scoping, which is the only behavioral hint.

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

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

A single, front-loaded sentence with no filler. The problem is under-specification rather than verbosity, but the one line is appropriately sized for what little it says.

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 annotations, no output schema, two parameters (one undocumented) and multiple near-identical sibling tools for invoices, the definition leaves an agent unable to predict results or choose confidently. It should at least define 'latest' and state the relationship to get_latest_invoices_for_period.

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

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

Schema description coverage is only 50%: resellerContext is documented in the schema, but groupByDepartments has no description anywhere. The description text adds zero parameter meaning, so it fails to compensate for the uncovered 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 essentially restates the tool name and title ('GetLatestInvoices' -> 'Get latest invoices'), adding only 'for the authenticated account'. It gives no indication of what 'latest' means (count, timeframe, ordering) and does nothing to distinguish it from the sibling get_latest_invoices_for_period or get_preview_invoices.

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

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

There is no guidance on when to use this tool versus get_latest_invoices_for_period, get_preview_invoices, or get_invoice_aggregation_report. A caller facing several invoice-related siblings gets no routing signal at all.

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, yet it discloses nothing about permissions, whether results are paginated or capped, what happens with the reseller context, or what the response contains. For a read tool with zero structured behavioral hints, this is a complete 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?

It is short, but the brevity is under-specification rather than efficiency: a single fragment that duplicates the title and adds no front-loaded substance an agent could act on.

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

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

With 4 parameters, no annotations, no output schema, and ambiguous siblings, the definition should explain scope, period semantics, and the effect of groupByDepartments. None of that is present, so an agent cannot confidently distinguish or invoke it.

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 25%, so the description must compensate and does not. It confirms year/month but gives no format or range guidance, and the two undocumented parameters (groupByDepartments, and the semantics of resellerContext beyond the schema note) 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 restates the tool name and title almost verbatim: 'GetLatestInvoicesForPeriod — invoices for year/month.' It conveys only the obvious (invoices, a period), with no distinction from siblings like get_latest_invoices or get_preview_invoices. This is tautology rather than a stated purpose.

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

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

There is no indication of when to use this tool versus the closely related get_latest_invoices or get_preview_invoices in the sibling list. No prerequisites, no exclusions, no alternatives are named.

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 behavioral burden. It says "Get" and scopes results to company-owned marketplaces, but it does not disclose auth requirements, pagination, return shape, or any other behavioral trait beyond the basic scope.

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?

It is a single short sentence with the scope front-loaded and no wasted words. The leading "GetMarketplaces" restates the name, which is slightly redundant but harmless.

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 getter, the description covers the core resource and ownership scope. However, with no annotations and no output schema, it leaves the return format and the exact boundary versus list_marketplaces unstated, which an agent would need to disambiguate.

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

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

The tool has zero parameters, so there is no parameter semantics to document. The baseline score of 4 applies because the schema has nothing for the description to compensate for.

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 gives a specific verb-and-resource combination: retrieving marketplaces, scoped to those owned by the company. The ownership scope distinguishes it somewhat from the sibling list_marketplaces, though it does not explicitly call out that alternative.

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

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

It implies use when owned marketplaces are needed, but it provides no explicit when-to-use guidance and no comparison to the closely related list_marketplaces or list_marketplace_services siblings. An agent must infer the distinction from the single word "owned."

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 exist, so the description bears the full disclosure burden, and it discloses almost nothing. It doesn't say whether the result is scoped by marketplace/reseller, whether it's paginated, or what a returned service entry contains — only an implicit read-only behavior from 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?

One short clause, front-loaded with the deciding information and no filler. It is efficient, though the leading name repetition does little work.

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 lookup tool with no output schema and no annotations, the description should at least indicate what comes back (service identifiers, names, pricing?) and whether results are filtered by reseller or marketplace. Without that, the agent cannot judge whether this or a sibling tool answers its question.

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 is a single parameter (parentAccountId) with 100% schema description coverage, so the schema already documents it and the baseline is 3. The description adds no meaning about what the parent account ID implies or how it constrains the result set.

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 adds a small clarification over the title — the services in question are ones a parent account can subscribe to — but it is essentially a restatement of the name. It never distinguishes this tool from the adjacent sibling get_possible_services_for_upgrade, so an agent must infer the difference from names alone.

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

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

There is no statement of when to call this versus get_possible_services_for_upgrade, get_available_services_for_marketplace, or list_marketplace_services, all of which sound closely related. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered, but the description adds nothing beyond that: no indication of what the result set represents, whether it depends on current subscription state, or how large/volatile it might be.

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?

It is short but not informative — a single fragment that repeats the tool name and parameter name without conveying any operational meaning. Brevity here comes from under-specification rather than efficiency.

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

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

For a read-only catalog lookup with one parameter this could be adequate, but the description never says what the returned services are for, when they become available, or what to do with them (e.g., feed into execute_subscription_upgrade). Key context is missing.

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

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

Schema coverage is 100% with a single required accountId parameter documented as 'ALSO Cloud Account ID'. The description merely echoes the parameter name, so the baseline 3 applies.

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

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

The description is essentially the tool name restated as a sentence: 'GetPossibleServicesForUpgrade for accountId.' It does not explain what a 'possible service for upgrade' is, nor how this differs from siblings such as get_possible_services_for_parent or get_subscription_fields_for_upgrade.

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

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

No guidance on when to use this tool, no prerequisites, and no mention of alternatives like get_possible_services_for_parent or execute_subscription_upgrade. An agent has to guess the workflow position from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: nothing about whether invoices are draft or finalized, whether figures are estimates that may change, permission requirements, or whether the call is free of side effects. Only the verb 'Get' implicitly signals a read.

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?

It is compact and front-loaded with no filler, but the brevity comes from under-specification rather than discipline — the single phrase does not earn its place as a sufficient definition.

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 two parameters, no annotations, and no output schema, the description needed to explain what a 'preview' invoice contains and how the results are shaped. It leaves the agent unable to predict the response or distinguish this from sibling invoice tools.

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

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

Schema coverage is 50%: resellerContext is documented in the schema, but groupByDepartments has no description anywhere, and the description does not mention either parameter. It could have explained what grouping by department changes in the output, which is the one genuinely non-obvious option here.

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 restates the tool name and adds only the qualifier 'current open billing month preview', which hints at a scope but never states what a 'preview invoice' actually is (draft, estimated, projected?). It partially separates the tool from siblings like get_latest_invoices by implying the current month rather than historical invoices, but the resource being returned remains ambiguous.

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

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

There is no guidance on when to call this instead of get_latest_invoices, get_latest_invoices_for_period, or get_invoice_aggregation_report, all of which sit adjacent and could plausibly return similar data. No prerequisites or exclusions are stated.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only enumeration and names the returned payload ('report names'), but says nothing about authorization, pagination, or whether execution needs a separate call — meaningful gaps for a tool with zero annotation coverage.

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

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

Two short sentences, zero filler. The positive statement of purpose is front-loaded and the exclusion follows immediately.

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?

A zero-param list tool with no output schema is simple enough that stating the returned item type ('report names') is nearly sufficient. The one remaining gap is how the output connects to execute_report, which the description leaves implicit.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain and the baseline applies. Nothing in the description misleads about inputs.

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

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

States a specific verb and resource ('list available report names') and immediately disambiguates against the two nearest siblings (find_companies / list_company_subscriptions). An agent can pick this tool without opening any schema.

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

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

The negative case is explicit and names the correct alternatives, which is stronger than most definitions. It stops short of positive guidance — it never says to call this first and then feed a name into execute_report, which would complete the routing picture.

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, yet it says nothing about permissions, whether the lookup fails when the account is absent, or what data class is exposed. The "Get" verb weakly implies a read-only lookup, but nothing beyond that is 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?

It is short and front-loaded, but at the cost of being under-specified — the single sentence largely duplicates the title and name rather than earning its place with useful 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?

There is no output schema, so the description should at least indicate what a "reseller" record contains or whether the call errors on unknown accounts. Neither is covered, leaving the agent unable to anticipate the response for a simple but under-explained lookup.

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

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

Schema description coverage is 100% and the single accountId parameter is documented as "ALSO Cloud Account ID" in the schema. The description's mention of accountId adds no semantics beyond that, so the baseline 3 applies.

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

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

The description is essentially a restatement of the tool name plus the lookup key: "GetReseller — reseller by accountId." It states the resource and identifier but adds no differentiation from siblings like get_resellers, get_reseller_by_vat_id, or get_company; the accountId detail is already in the schema.

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

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

No guidance on when to use this versus get_resellers (list) or get_reseller_by_vat_id (VAT lookup), which are the obvious alternatives. An agent must infer the choice purely from the shared accountId parameter.

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 behavioral burden, and it discloses nothing: not what happens when the VAT ID is unknown (error vs. empty), whether the lookup is exact-match or normalized, nor what fields a reseller record contains.

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

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

It is short, but this is under-specification rather than conciseness — a four-word restatement of the name that earns no informational value and is not front-loaded with any useful context.

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 lookup with no annotations or output schema, the description should at least describe the not-found behavior and the shape of the returned reseller. None of that is present, leaving the agent unable to predict the response.

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

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

Schema description coverage is 100% and the single parameter already documents "VAT / UID number" with a minLength constraint, so the schema does the work. The description adds nothing on format (country prefix, digits only) but the baseline of 3 applies when coverage is complete.

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 is essentially the tool name reworded: "GetResellerByVatId" for get_reseller_by_vat_id. It conveys no resource detail beyond the identifier and does not distinguish this tool from the closely related siblings get_reseller or get_company_by_vat_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?

There is no guidance on when to use this lookup versus get_reseller (which presumably fetches by other identifiers) or get_company_by_vat_id. The agent is left to infer the selection rule entirely from the 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 behavioral burden, yet it says nothing about permissions, pagination, truncation, or what happens when parentAccountId has no resellers or is invalid. The single scoping phrase about parentAccountId is the only added 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?

One short clause with no filler, and the key scope qualifier is front-loaded in the same breath as the verb. It is efficient, though arguably under-specified rather than well-edited.

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-style retrieval tool with no annotations and no output schema, the description should at least hint at what comes back (fields, ordering, result size). It supplies none of that, leaving the agent with only the input constraint.

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

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

Schema description coverage is 100% and the sole parameter already documents itself as 'Parent Account ID'. The description only repeats that name in a relational phrase, adding no format, type, or constraint detail beyond the schema, so baseline 3 applies.

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

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

The description pairs the verb 'GetResellers' with the resource and adds a scoping relation ('under parentAccountId'), which implies a filtered list rather than a single fetch. But it largely restates the tool name and title, and it never says explicitly that it returns a collection or how it differs from the singular sibling get_reseller.

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 statement of when to use this versus get_reseller, get_reseller_by_vat_id, or create_reseller/update_reseller, all of which appear in the sibling list. The only implicit cue is the plural resource name; nothing tells the agent about prerequisites or exclusions.

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

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

With no annotations, the description carries the full disclosure burden but only hints that roles are scoped to a company or reseller account. It does not state whether the operation is read-only, what the result set looks like (names, IDs, permission sets), whether pagination applies, or what permissions are needed.

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?

It is a single short sentence with no waste, but the brevity comes at the cost of substance rather than through tight editing. Being front-loaded is moot when there is only one clause.

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?

A one-parameter, no-output-schema, no-annotation tool needs the description to explain what comes back and how the account type affects results. Neither is covered, leaving the agent unable to predict the response shape or scope.

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

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

Schema coverage is 100% and the single parameter is documented as "ALSO Cloud Account ID". The description's "company/reseller" phrasing adds a small amount of meaning — that the same ID space covers two account types — but no format or optionality guidance 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 essentially restates the tool name and title ("GetSecurityRoles") and appends only "for company/reseller accountId". It gives no verb-plus-resource framing beyond what the name already conveys and does nothing to separate it from the many other get_* list tools in the sibling set.

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

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

There is no guidance on when to call this versus alternatives, no preconditions, and no mention of what an agent should do if it lacks an accountId. The only implied context is that the tool relates to an account, which an agent could infer from the parameter name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. The verb "Get" weakly implies a read operation, but the description says nothing about permissions, error behavior, or what information is retrieved beyond the service name.

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 single sentence is short but under-specified rather than genuinely concise. It front-loads a restatement of the tool name without adding useful information.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is insufficient. It does not explain what service information is returned or how to correctly supply the serviceName.

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 the undocumented serviceName parameter. Instead, it merely repeats the parameter name without explaining expected format, source, case sensitivity, or validity constraints.

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 "GetServiceInformation by serviceName" essentially restates the tool name and its required parameter without clarifying what service information is returned. It does not distinguish this tool from nearby siblings such as get_fields_for_service, list_marketplace_services, or get_possible_services_for_parent.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent is left to infer usage entirely from the name and parameter.

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 behavioral burden, and it discloses almost nothing: not that it is a read-only lookup, not what happens when no special deal exists, not whether it requires special permissions. 'Get' weakly implies a read, but nothing beyond that is 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?

It is a single short sentence with no filler, which is appropriately sized on its face. However, the brevity comes at the cost of under-specification rather than genuine conciseness — the one clause it has is grammatically awkward and front-loads a restated tool name.

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 annotations, no output schema, and no explanation of what a 'special deal' or discount structure looks like, an agent cannot predict the return value or error behavior. For a lookup tool in a billing/subscription domain, this leaves significant gaps that the description should have filled.

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

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

Schema description coverage is 100% and the single accountId parameter is documented as 'ALSO Cloud Account ID', so the schema does the work. The description adds no meaning beyond naming accountId, which matches the baseline 3 for fully-covered schemas.

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 resource (special deal discounts) and the key scope (an accountId), so an agent can roughly infer it retrieves special-deal discount information for an account. But the phrasing 'GetSpecialDeal discounts' is awkward and near-tautological with the tool name, and it never says what form the 'discounts' take. It does not distinguish itself from close siblings like set_special_deal or get_subscription.

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 indication of when to use this versus alternatives, no mention of prerequisites, and no acknowledgment of the natural counterpart set_special_deal (write vs. read). The only signal is the implicit 'get' verb, which is insufficient guidance for an agent choosing among ~50 siblings.

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 disclosure burden, and it discloses almost no behavior: nothing about read-only semantics, behavior when the account has no subscription (error vs empty), or what resellerContext changes. The only behavioral note ('compact=true by default') merely restates the schema 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?

Three short sentences, no filler, with the identification and the alternative-routing hint front-loaded. Every sentence carries information the agent can act on.

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

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

For a simple single-entity read with a fully documented schema, this is close to adequate, but with no output schema and no annotations the agent still lacks any sense of the returned payload's shape (beyond the compact flag) or failure mode for an unknown accountId.

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

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

Schema description coverage is 100%, so all three parameters are already documented, including compact's payload-shape implication and resellerContext's optionality. The description adds the compact default but no meaning beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource ('GetSubscription') and pins the lookup key ('by accountId'), so the agent knows this is a single-entity fetch. It does not, however, differentiate itself from the very similarly named siblings get_subscriptions and get_subscription_with_addons.

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?

One explicit routing hint is given ('Prefer list_company_subscriptions for company-wide lists'), which is genuinely useful. But the closest alternatives — get_subscriptions (plural list) and get_subscription_with_addons — are not addressed at all, leaving the agent to guess between near-identical names.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond that, such as what is returned, whether any account state is required, or what makes the result renewal-specific.

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 brief, but it is a single tautological fragment rather than a front-loaded explanation. Its concision comes at the cost of useful information, so it is under-specified rather than appropriately 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 read-only, single-parameter getter this could be short, but the output is undocumented and there is no output schema. Given the many sibling tools around subscriptions and renewals, the description does not provide enough context for an agent to confidently choose and invoke it.

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

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

Schema description coverage is 100%, and the accountId parameter is already documented as the ALSO Cloud Account ID. The description only repeats 'for accountId' and adds no format, scope, or semantic detail beyond the schema, so the baseline 3 applies.

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

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

The description essentially restates the tool name and title: 'GetSubscriptionFieldsForRenew for accountId.' It does not explain in plain language what subscription fields are retrieved or why they are specifically for renewal, and it does not distinguish the tool from the nearby get_subscription_fields_for_upgrade.

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

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

There is no guidance on when this tool should be used, when it should not be used, or how it relates to alternatives such as get_subscription_fields_for_upgrade, configure_subscription_renew, or reset_default_renew_values. The only usage condition implied is that an accountId is required, which is already obvious from the schema.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered; the description adds nothing on top — no indication of what the returned fields are, whether they must be fed to execute_subscription_upgrade, or any preconditions. No contradiction, but zero added behavioral context.

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

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

It is short, but that brevity reflects under-specification rather than economy; the single fragment is not even a complete sentence and front-loads nothing actionable beyond the name.

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 read with no output schema, the description still leaves the agent unable to predict what comes back or how to chain into the upgrade execution tools, which is the whole point of this tool. It is inadequate relative to the surrounding workflow.

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 accountId ('ALSO Cloud Account ID') and targetProductName ('Technical name of the destination product') are already fully documented in structured data. The description only echoes the parameter names, adding no format or constraint detail — baseline 3 applies.

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

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

The description is essentially the tool name with its two parameters appended; 'GetSubscriptionFieldsForUpgrade' does signal a read of subscription fields in an upgrade context, but the sentence adds no explanation of what those fields are or how they differ from get_subscription_fields_for_renew or validate_subscription_fields. This is tautology against the title, not a stated purpose.

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

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

There is no when-to-use guidance and no mention of alternatives, despite a dense sibling cluster (execute_subscription_upgrade, get_possible_services_for_upgrade, validate_subscription_fields, get_subscription_fields_for_renew). Only the tool's own name implies the upgrade 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 present, the description carries the full behavioral burden. It does add useful context that compact=true is the default and drops large Fields arrays, but it says nothing about permissions, pagination, result volume, or what the non-compact payload looks like.

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

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

Three short sentences, front-loaded with the operation and scope, then the sibling routing, then the default behavior. Very little waste, though the quoted-phrase routing sentence is slightly compressed and the tool name is repeated verbatim rather than described.

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 five-parameter read tool with no annotations and no output schema, the description covers the two things an agent most needs: the required scope and the default compact behavior. Return shape details are only partially implied via the compact mention, leaving a small gap.

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

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

Schema description coverage is 100%, so all five parameters including compact, activeOnly, resellerContext, and excludeUserLevel are already documented in the schema. The description restates the compact default rather than adding interpretation, so baseline 3 applies.

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

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

States a specific verb and resource ('GetSubscriptions') scoped to a parent account, which is concrete enough to act on. It does distinguish from list_company_subscriptions for the name-based lookup case, but the phrasing 'GetSubscriptions under parentAccountId' is terse and carries mild ambiguity about whether it returns one or many.

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 names an alternative tool and the condition that should route to it ('subscriptions of company X by name' -> list_company_subscriptions). It gives clear positive context but no guidance on when NOT to use it beyond that single case (e.g., vs get_subscription for a single ID).

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: 'Get' implies a read, but it never states that it is read-only/non-mutating, what permissions or reseller context are required, or what happens if the account has no subscription. For a tool with zero annotation coverage 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?

A single short sentence with the key scope ('one subscription including addons') front-loaded and no filler. It is efficient, though its brevity comes partly from saying little of substance.

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 read tool with full schema coverage, the description is minimally viable. But with no annotations and no output schema, the phrase 'full detail' is left undefined - the agent cannot tell what fields or addon data come back, which is the main open question.

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 both accountId ('ALSO Cloud Account ID') and resellerContext are already documented in the schema. The description adds no syntax, default, or behavioral meaning beyond that, so the baseline 3 applies.

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

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

The description states a verb and resource ('full detail for one subscription'), and the phrase 'including addons' hints at what separates it from the sibling get_subscription. However, it mostly restates the tool name/title and never explicitly contrasts itself with get_subscription or get_subscriptions, so an agent must infer the distinction.

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 when-to-use guidance, no prerequisite (e.g., needing an existing subscription ID or account context), and no named alternative. With sibling tools like get_subscription and get_subscriptions in scope, the agent gets no routing help at all.

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 behavioral burden. It does not state whether the call is read-only (implied only by the name), what happens if accountId doesn't exist, what permissions are needed, or what the response contains.

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

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

It is a single terse fragment with zero filler, so it is front-loaded, but the brevity comes from under-specification rather than efficiency. One more sentence on return shape or ID expectations would have earned its place.

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

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

For a simple one-parameter read tool this could be complete with one clarifying clause, but the description says nothing about the returned user object, error behavior on unknown IDs, or how it relates to sibling user tools. With no annotations and no output schema, too much is left implicit.

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

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

Schema description coverage is 100% — the single accountId parameter is documented as "ALSO Cloud Account ID" — so the schema does the heavy lifting. The description adds nothing beyond repeating that the lookup is by accountId, matching the baseline 3 for full schema coverage.

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

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

"GetUser — user by accountId" largely restates the tool name and title, adding only that the lookup key is accountId. It does not distinguish this single-user fetch from the sibling get_users (plural list) or explain what a 'user' record contains.

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

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

There is no guidance on when to use this instead of get_users, update_user, or get_company. The agent must infer that this is the single-record lookup by ID purely from the 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 behavioral burden. It does not state that it is a read-only listing, whether results are paginated, or what happens with invalid companyAccountId — all material for a list tool with zero annotation coverage.

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

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

Extremely short and front-loaded, so there is no waste, but the single sentence mostly echoes the tool name and contributes little unique information. Brevity here reflects under-specification rather than efficiency.

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 one parameter, no annotations, and no output schema, the description should explain the list semantics and return shape. It does neither, and it never routes the agent away from the singular get_user sibling.

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

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

Schema coverage is 100% with a single required parameter, so the schema already documents companyAccountId. The description only restates that users fall under companyAccountId, adding no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a verb (GetUsers) and resource (users), scoped by companyAccountId. However, the title merely restates the name, and the description does not distinguish this from the sibling get_user (singular), leaving the agent to infer the list-vs-single relationship.

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 when-to-use guidance, no exclusions, and no mention of the closely-related get_user sibling. The agent must guess whether this is the right tool for a single-user lookup versus a 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 exist, so the description carries the full burden. It does disclose the return shape well (tags, summaries, tool-name mapping, write/destructive risk flags), which is genuinely useful. But it never states that the call is read-only/side-effect free, whether the catalog is paginated or complete, or how large the response typically is.

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

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

A single compact sentence that front-loads the resource and lists the returned fields; no filler. It is a sentence fragment rather than a complete statement of the tool's action, which slightly weakens the lead.

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 two-optional-param discovery tool with no output schema, the description is adequate: it explains what comes back and the fields are self-describing. What is missing is the operational context — that this is a meta/discovery endpoint meant to be consulted before choosing among the many sibling tools, and any note on catalog 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?

Schema description coverage is 100%, with both `tag` and `onlyReadable` documented including an example value, so the baseline is 3. The description adds nothing beyond the schema, though 'write/destructive risk flags' loosely explains why `onlyReadable` exists.

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

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

The description names a specific resource — a catalog of MarketplaceSimpleAPI 1.0.0 endpoints — and enumerates the payload (tags, summaries, MCP tool names, risk flags), so an agent can tell it apart from the domain-specific siblings. It is phrased as a noun fragment rather than a verb+resource statement, so the 'list' action is only implied by the title, not the description itself.

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

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

There is no statement of when to call this versus the ~60 domain tools, and no mention of the discovery workflow it enables (e.g., 'call this first to find the right tool'). The only usage-adjacent hint is the phrase 'dedicated MCP tool names (if any)', which hints at a routing role but never states it.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is set; the description adds real value by disclosing the two-step resolution (company lookup then GetSubscriptions) and the shape of the result. It stops short of covering failure behavior when a company name doesn't resolve or any result-size limits.

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

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

Four short sentences, front-loaded with the preferred-use case, then mechanism, then return shape, then the default flag. No filler and nothing redundant with the schema.

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

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

With no output schema, the description correctly covers the return value at a summary level (compact, no huge Fields arrays) and explains input resolution. It omits what happens when the company cannot be found and whether results are paginated, which are the remaining gaps for a lookup-style tool with five optional params.

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 80%, so the baseline is 3; the description earns an extra point by explaining the accountId-vs-companyName interaction and the implicit dependency on find_companies, and by restating activeOnly's default=true meaning. excludeUserLevel and parentAccountId remain undiscussed in the description.

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

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

States a specific verb+resource (list subscriptions for a company) and pins it to a concrete user question, "which subscriptions does company X have?". It also differentiates itself from the many subscription siblings by advertising a compact result rather than full Fields arrays.

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?

"PREFERRED for ..." gives an explicit selection signal, and the resolution order (accountId or name via find_companies) tells the agent how to prepare inputs. It never states the inverse condition directly (e.g. use get_subscriptions when you need full field arrays), leaving that to inference from "no huge Fields arrays".

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the 'pending' state qualifier, which is meaningful context, but says nothing about ordering, volume, pagination, or what fields each order carries.

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?

Extremely short and front-loaded, with no wasted words, but it errs toward under-specification rather than crispness — a single noun phrase carries the entire definition.

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 parameters and no output schema, the description should at least indicate what each returned order contains or how the result is meant to be used with the approve/decline tools. It conveys the record type and state but leaves the agent to guess the return shape.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain; baseline 4 applies. The description does not need to compensate for anything here.

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?

Restates the tool name and appends 'pending credit check orders', which adds a useful state qualifier over the bare name. However, it does not differentiate from the closely related approve_credit_check_order / decline_credit_check_order siblings or explain what an 'order for approval' is beyond the name itself.

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

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

No guidance on when to call this versus the approve/decline siblings, no prerequisites, no mention of when the list would be empty. The agent must infer that this is the discovery step preceding approval actions.

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 exist, so the description carries the burden; it discloses that the data is static (no side effects, no live API ownership lookup) and that no credentials are needed. It stops short of describing the exact return shape (a flat key-to-URL map?), which is the only remaining gap for a zero-param 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?

Two sentences plus an example list, zero filler, with the core mapping front-loaded and the sibling routing rule second. The parenthetical examples earn their place by clarifying what a 'country key' looks like.

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 trivial zero-param static lookup with no output schema, the description covers purpose, safety, and alternative. A brief note on the response shape (e.g. map of key to URL) would fully close it, but nothing prevents a correct 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 tool takes zero parameters, so the baseline is 4. The description's mention of 'country keys' is contextual framing rather than parameter documentation, and nothing is missing.

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

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

States a specific mapping (static country keys to marketplace base URLs) with concrete example keys, and explicitly names the sibling get_owned_marketplaces as the different thing. An agent can distinguish it from the many get_* tools without opening a schema.

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

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

Gives an explicit routing rule: use this for static country keys, use get_owned_marketplaces for API-owned marketplaces. It also notes no credentials are required, so the agent knows no auth flow precedes the call.

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, yet it discloses nothing about permissions, pagination, whether the list is filtered/active-only, or what the result looks like. It is a tautology with a parameter echo.

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?

It is short and front-loaded with no padding, but that brevity stems from under-specification rather than efficiency — nothing substantive is communicated.

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

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

For a tool with no annotations, no output schema, 0% parameter coverage, and four-plus similarly named siblings, the description supplies essentially none of the context needed to select or invoke it correctly.

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

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

Schema coverage is 0% and the single parameter is an untyped-in-practice integer with no description; the text only names 'marketplaceId' without explaining format, source of valid IDs (e.g., from list_marketplaces/get_owned_marketplaces), or required scope.

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 merely restates the tool name (list marketplace services) plus the parameter name, adding no scope, output, or differentiation. An agent cannot tell from this text how it differs from siblings like get_available_services_for_marketplace or get_possible_services_for_parent.

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

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

There is no guidance on when to use this tool, when not to, or which of the many service-listing siblings is the alternative. The existence of at least three similar service/marketplace tools makes this omission costly.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true. The description usefully adds that the operation removes saved renew configuration scoped to one account, which is the main thing an agent needs to know before calling. There is slight friction between 'clears' and destructiveHint=false, but a reset to defaults is plausibly reversible, so this is not scored as a contradiction.

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

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

One short, front-loaded sentence where the mutation signal comes first. Minor waste in repeating the internal method name 'ResetDefaultRenewValues' alongside the tool name.

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 mutation with annotations and a fully documented schema, most of the burden is covered elsewhere. What is missing is the relation to configure_subscription_renew and any statement of what happens after the reset, which an agent selecting among renewal tools would want.

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

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

Schema coverage is 100% and the single accountId parameter is already documented as the ALSO Cloud Account ID. The description only restates the parameter name, adding no format, sourcing, or lookup guidance 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 verb 'clears' plus the resource 'saved renew config' for a specific accountId makes the effect concrete and distinguishable from the plumbing-name title. It does not, however, contrast itself with the closely related sibling configure_subscription_renew.

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 'WRITE:' prefix signals mutability, but the description never says when an agent should reset versus call configure_subscription_renew, nor what prerequisites or account state make this appropriate. The choice between the two is left entirely to inference.

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

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

Annotations already declare readOnlyHint=false, so the leading 'WRITE:' adds nothing beyond structured data. The description does not say what happens if no failed provisioning exists, whether the retry is idempotent, whether it blocks or is async, or what side effects/permissions apply for a mutating, open-world 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?

One short sentence with no filler, and the write nature is front-loaded. However, it reads as a telegram-style fragment rather than a purposeful summary, so brevity comes at the cost of useful 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 mutating retry operation with no output schema, the description leaves the agent without outcome information: no mention of what a retry returns, failure modes, or state requirements. Given the annotations only cover safety hints, the description should carry more of this burden.

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

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

Schema description coverage is 100% and the single parameter is documented as 'ALSO Cloud Account ID'. The description only restates that the accountId identifies the subscription, adding no format or sourcing guidance beyond the schema. Baseline 3 applies.

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

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

States a specific verb (Retry) and resource (last failed provisioning), scoped to a subscription accountId. This distinguishes it from read-oriented siblings like get_subscription, though the phrase 'for a subscription accountId' is awkwardly worded rather than explanatory.

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 indication of when this should be invoked versus other subscription tools, nor any precondition such as 'only valid if a prior provisioning failed.' The agent must infer the trigger condition entirely from the name.

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

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

Annotations already flag readOnlyHint=false and destructiveHint=false, so the write nature is known; the description still adds real value by disclosing that an omitted limit silently clears the existing credit limit and that comment is required. This reveals a consequential side effect the annotations do not. It stops short of describing permissions, validation failures, or response behavior.

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

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

Two short sentences with the write marker and the clearing behavior front-loaded; nothing wasted. The 'SetCreditLimit' token partly duplicates the tool name and title rather than adding 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 mutation with no output schema, the description covers the critical input semantics but says nothing about what is returned, whether the previous limit is recoverable, or any error conditions. Adequate to call correctly, thin on consequences.

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

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

Schema coverage is 100%, so the schema already documents all three parameters, including 'omit to clear per API rules' and the reason field for comment. The description restates those facts ('Omit limit... comment is required') rather than adding syntax, range, or format detail, so baseline 3 applies.

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

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

The description gives a specific verb and resource ('WRITE: SetCreditLimit') and adds the key semantic that omitting limit clears it, which lets an agent separate it from get_credit_limit. It doesn't explicitly name the read counterpart, but the write framing makes the distinction clear.

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

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

It states the two operating modes (set a value vs. omit to remove) and that comment is mandatory, which is genuinely useful invocation guidance. It never says when to prefer this over sibling tools such as approve_credit_check_order or when a credit limit change is appropriate, so usage is only 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description contributes the upsert semantics ('create/update'), which meaningfully tells the agent the call is safe to repeat on an existing accountId, but it says nothing about effect on prior deal values, permissions, or errors.

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

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

A single front-loaded sentence with the operation type first and the resource second; nothing is wasted. It is arguably too terse for a nested-payload mutation, but brevity itself is not a fault here.

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 a free-form nested payload, no output schema, and no annotation coverage of side effects, the description omits what a special deal actually is, what fields it accepts, and what the result looks like. The agent can identify the tool but cannot construct a confident 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?

Schema description coverage is 100%, so accountId and specialDeal are already documented at the field level. However, specialDeal is an opaque nested object with additionalProperties={} and the description adds no information about what a special deal payload should contain — the highest-value clarification is missing.

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

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

States a specific verb+resource combination ('create/update special deal discount') scoped to an accountId, which is clearly distinguished from the sibling read tool get_special_deal. It does not name that sibling explicitly, but the write/read split 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 'WRITE:' prefix implies this is a mutation, but there is no guidance on when to use it versus get_special_deal or the other subscription/deal tools, and no stated prerequisites (e.g., existing account, required permissions). The agent is left to infer the trigger condition.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, and the description is consistent with a write operation. It adds the useful payload instruction to include accountId and fields to change, but does not explain partial-update semantics, permissions, or what happens to unspecified fields.

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

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

Two short sentences with no wasted text, and the WRITE label plus operation name are front-loaded. The payload guidance follows immediately.

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 write tool with an open nested object payload and no output schema, the definition is workable but thin. It covers the basic invocation shape but omits whether updates are partial or full, what fields are permitted, and what the tool returns.

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 nominally 100%, but the schema only defines an open-ended company object with no documented properties. The description adds meaning by naming accountId and fields to change, but it does not identify valid field names or payload format, so it 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 verb and resource: update a company via UpdateCompany, and labels it as a WRITE operation. It is clear what the tool does, though it does not explicitly distinguish itself from siblings like create_company or get_company.

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 says to pass a company object with accountId and fields to change, which is invocation guidance rather than usage guidance. It does not explain when to use this instead of create_company, get_company, or other update tools, and gives no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the "WRITE:" prefix adds nothing new. What the description does add is that accountId is required inside the payload — a requirement absent from the opaque nested-object schema. It says nothing about partial-update semantics on omitted fields, error behavior, or permissions.

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-loaded with the operation type, with no filler. The "UpdateDepartment" token mildly restates the tool name and the title, but the payload hint earns its place.

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

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

For a single-parameter nested-object mutation with no output schema and no annotations covering semantics, the description gives just enough to construct a payload but omits what a successful response contains and how unspecified fields are treated. 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 nominally 100%, but the nested department object is declared with empty additionalProperties, so the schema alone tells an agent nothing about its contents. The description compensates meaningfully by naming accountId as a payload member and framing the rest as "fields to change".

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

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

States a specific verb and resource ("WRITE: UpdateDepartment") and adds that the payload carries accountId plus "fields to change", which signals partial-update semantics. It does not distinguish itself from siblings such as create_department or get_department, 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?

No guidance on when to use this versus create_department, get_department, or get_departments. The only invocation hint is the imperative "Pass department object with accountId", which describes how to call it, not when.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the "WRITE" label adds nothing structured data doesn't cover. The description omits the behaviors that matter for a mutation: whether the update is partial (merge) or replaces the whole reseller, what happens to omitted fields, and any permission 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?

Two short sentences with the mutation flag front-loaded and the payload instruction second, in the right order. Minor waste in restating the tool name as "UpdateReseller" before saying anything new.

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 write tool taking a free-form nested object with no output schema, the description should say whether unspecified fields are preserved and what a successful response contains. None of that is present, so an agent must guess at merge semantics before invoking a mutation.

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

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

Schema coverage is 100% but only nominally: the reseller object is additionalProperties with no defined properties, so the schema itself reveals nothing about its contents. The description compensates by naming accountId as the identifier and stating the remaining keys are "fields to change", which is genuinely additive given the opaque nested payload.

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 verb+resource is stated ("WRITE: UpdateReseller"), but it largely restates the tool name/title rather than describing the operation in its own terms. It adds the payload shape but never says what kind of reseller fields are being changed or what the outcome is, and it does not distinguish itself from create_reseller or get_reseller.

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 "WRITE:" prefix signals a mutation, but there is no guidance on when to use this versus create_reseller (for new resellers) or when an update is not appropriate. No prerequisites, no exclusions, no mention of a retrieval step to obtain accountId first.

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 'WRITE:' prefix only restates readOnlyHint=false that annotations already declare. It says nothing beyond annotations about partial-vs-full update semantics, whether unlisted fields are wiped, whether validation is a prerequisite, or the effect of openWorldHint=true — all real risks for a mutation with a free-form payload.

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, mutation nature front-loaded, no filler. The terseness edges toward under-specification rather than verbosity, but nothing 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?

A destructive-adjacent mutation of a nested, open-world object with no output schema demands more: which fields are mutable, how validation errors surface, and the relation to the validate/upgrade siblings. Given that complexity, the two-sentence description leaves substantial 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?

Although schema coverage is nominally 100%, the schema for the single parameter is an unconstrained object with additionalProperties {} and only the phrase 'Subscription update payload'. The description genuinely adds that accountId is expected and that remaining keys are field changes, which is more than the schema conveys, but no field names or formats are given.

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?

Names a specific verb and resource ('UpdateSubscription') and hints at payload shape (accountId plus field changes), which separates it from read siblings like get_subscription and from create_subscription. It stops short of differentiating it from the many adjacent mutation tools (execute_subscription_upgrade, configure_subscription_renew), so it is clear but not fully sibling-aware.

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 statement of when to use this versus validate_subscription_fields, execute_subscription_upgrade, configure_subscription_renew, or reset_default_renew_values — all of which touch the same object. The agent is left to infer that this is the generic field-mutation path.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true. The description's 'WRITE' label largely restates this and adds only a payload hint; it does not explain mutation effects, permissions, partial-update behavior, or what happens to unspecified settings.

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 and front-loads the operation type. It is efficient, though its terseness borders on under-specification rather than being fully optimized.

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 a nested, largely unconstrained user payload and no output schema, the description does not provide enough detail about valid fields, whether updates are partial or full, required nested properties, or expected effects.

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. The description adds some meaning beyond the schema by naming accountId and settings to change, but it remains vague about valid setting fields and the nested object is otherwise unconstrained.

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: updating a user, and explicitly labels it as a WRITE operation. It is clear enough to distinguish the operation from read tools like get_user, though it does not differentiate itself from siblings such as create_user or update_company.

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 only says to pass a user object with accountId and settings to change. There is no guidance on when to use this tool versus create_user or other update tools, no prerequisites, and no 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the check is optional and that other tools handle login automatically, but it does not describe what the check returns, whether it has side effects, or what happens on failure.

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 waste. The optional nature is front-loaded, followed immediately by the key usage 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?

For a zero-parameter, no-output-schema health check, the description is nearly sufficient: it explains the tool's optional role and the automatic-login context. It could be slightly more complete by stating what the check returns or the exact situation in which it should be used.

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

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

The tool has zero parameters, so the baseline is 4. There are no parameter semantics to explain beyond the empty 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?

States that this is an optional health check (PingPong), which clarifies its role as a session validation utility. It does not explicitly say it validates the current session, but the name/title plus the warning distinguish it enough from normal query 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?

Gives a clear usage constraint: it is optional and should not be called before every query because login is automatic on other tools. It lacks a positive trigger such as 'use only when a session may have expired,' so it is strong but not complete.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true; 'WRITE-ish' is consistent with that, not contradictory. The description adds one genuinely useful fact — it does not provision — but says nothing about what happens on invalid input, whether it is idempotent, or what it returns.

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 clauses, front-loaded, with zero filler. It is arguably under-specified rather than verbose, but nothing 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?

For a validation tool with no output schema, the agent has no idea whether success returns a boolean, an error list, or throws — a significant omission. The 'does not provision' boundary is helpful but does not close that gap.

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