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

The description asserts 'Active state is treated idempotently' while the annotations declare idempotentHint=false. This directly contradicts the structured metadata, which is the most consequential behavioral claim for a caller deciding whether repeat invocation is safe. Per the rules, a description that contradicts annotations scores 1.

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

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

Two tight sentences with the action front-loaded and the configuration scope second. Little waste, though 'step 2' costs a clause without earning clarity for an agent that has no surrounding workflow 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?

This is a high-complexity mutation with 6 parameters, a nested settings object, no output schema, and very low schema coverage. The description omits the plan/apply distinction details, required credential fields, and any return/confirmation behavior, leaving significant gaps 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 only 17% across 6 parameters, so the description must compensate, yet it only names broad settings categories (webhooks/chat/tips/channels). It gives no meaning for mode values (plan vs apply), confirmation, partner_id ownership semantics, or the required login/api_key/secret_key fields.

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?

State a specific verb and resource: 'activate a pending installation and configure entity webhooks/chat/tips/channels.' This distinguishes it from read-only siblings like marketplace_get_installation_status and marketplace_list_installations. However, it does not explicitly name a sibling alternative and 'step 2' is left unexplained.

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?

'Plan or perform step 2' implies a two-phase workflow that maps to the mode enum, giving implied usage context. But there is no explicit statement of when to prefer this over alternatives (e.g., marketplace_get_installation_status) or prerequisites like the existence of a pending installation.

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

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

Annotations already mark the tool as destructive and not read-only. The description adds valuable context beyond that: it discloses cascade deletion ('partner-linked entities') and a default-disabled state, which affects invocation and risk assessment. However, it does not describe irreversibility, permissions, or mode 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 tight sentences: the first states the action and scope, the second front-loads the critical safety warning. Every phrase earns its place and there is 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 highly destructive tool with a plan/apply workflow and a confirmation parameter, the description omits essential invocation details. While it correctly signals danger and disabled-by-default status, it leaves the agent unable to determine how to safely execute or dry-run the deletion.

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

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

Schema description coverage is 0%, and the description does not mention any of the three parameters. Critically, it omits the required 'mode' parameter and its plan/apply semantics, and does not explain the 'confirmation' parameter. No parameter meaning is added beyond the bare schema.

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

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

States a specific verb ('Delete') and resource ('an application'), with additional scope ('partner-linked entities through the internal backoffice API'). This clearly distinguishes it from sibling delete tools like marketplace_backoffice_delete_offer and marketplace_delete_developer_account.

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 warns that the tool is 'Disabled by default and highly destructive,' which implies caution, but provides no explicit guidance on when to use it versus alternatives. It does not mention prerequisites such as enabling the tool or using the plan mode 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?

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds the valuable 'Internal API; disabled by default' context, but omits what actually happens on deletion and whether the mode parameter provides a dry-run, which matters a great deal for an irreversible 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?

Two tight sentences, front-loaded with the action and resource. Nothing is wasted, though the second sentence is terse enough to be cryptic rather than merely concise.

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

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

For a destructive, non-idempotent tool with no output schema and zero parameter documentation, the description should explain the mode semantics, the confirmation field, and the disabled-by-default implications. It gives a single precondition and leaves the operational mechanics unexplained.

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

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

Schema description coverage is 0% for three parameters, so the description carries the full burden and provides nothing. In particular the 'mode' enum (plan vs apply) strongly suggests a preview/commit pattern and 'confirmation' suggests a safety gate, yet neither 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?

States a specific verb and resource ('Delete an internal Marketplace special offer'), which is distinguishable from siblings like upsert_offer, list_offers, and delete_application. It does not explicitly name the contrasting sibling, but the resource qualifier 'internal special offer' pins it down well.

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 notes the tool is an 'Internal API; disabled by default', which is a real usage precondition, but it never says when to use this deletion versus upsert_offer or delete_application, nor does it explain the plan/apply modes that presumably govern whether anything is actually deleted.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, so the bar is lower. The description nonetheless adds meaningful context beyond them: that this is not a public API and is disabled by default, which is a real operational precondition. It stops short of saying how to enable it or what permissions are required.

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

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

Two short sentences with no filler, and the domain/scoping statement is front-loaded. It is appropriately sized for what it conveys, though the second sentence could be more actionable.

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

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

For a single-parameter read tool whose annotations already declare the safety profile, the missing parameter meaning is the main gap, and there is no output schema to compensate. The description is minimally adequate but leaves the agent to infer the argument's identity 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 description coverage is 0%, so the description must carry the burden for the single application_id parameter, and it says nothing about it. The agent must infer that the required integer identifies the application being read.

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 says it reads 'internal Marketplace backoffice data,' which conveys the domain but never names the resource (an application record) that the tool name implies. It also fails to distinguish this tool from the sibling marketplace_get_application, so an agent cannot tell why this one exists alongside it.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as marketplace_get_application. The 'disabled by default' note hints at a precondition but does not tell the agent when this tool is the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful non-annotation fact — that this is an internal API disabled by default — but says nothing about return shape, pagination, or what 'disabled' means operationally for the caller.

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 purpose front-loaded and the constraint immediately after. No filler or redundancy.

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

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

With zero parameters, no output schema, and annotations covering the safety profile, the description carries little burden. The 'internal API, disabled by default' caveat is the key thing an agent needs to know, though a note on expected behavior when disabled would round it out.

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 no schema gap to compensate for. Baseline for a parameterless tool 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 (List) and a scoped resource (internal Marketplace special offers), which distinguishes it from the many get/list siblings by narrowing to internal backoffice offers. It does not explicitly contrast itself with related siblings such as marketplace_list_applications, but the resource is specific enough for an agent to identify it.

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 only usage signal is 'Internal API; disabled by default,' which is an availability caveat rather than guidance on when to choose this over alternatives. There is no explicit when-to-use or when-not-to-use framing, and no mention of what to do if the API is disabled.

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, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partially covered. The description adds genuinely useful context that the API is internal and disabled by default, but says nothing about what 'apply' changes, whether a confirmation token is required, or whether a plan call is side-effect free.

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, front-loaded sentences with no padding; the core action leads and the operational caveat follows. It is efficient, though the brevity contributes to the semantic gaps above.

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 non-idempotent, non-read-only mutation tool with 5 undocumented parameters, a confirmation field, and no output schema, the description is far too thin. It omits prerequisites, the meaning of mode values, and any indication of what a successful call returns or changes.

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 5 parameters, so the description must carry the load and it does not. It names commission/boost conceptually but never explains the plan/apply mode enum, the purpose of the 'confirmation' string, or why application_id is required.

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?

It gives a verb pair (plan/set) and the resource (internal commission/boost values), but never says what entity these values attach to (implied only by the required application_id) and never reconciles the 'commercials' name with the commission/boost fields. An agent can guess the domain but not the exact effect.

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 mention of the plan-vs-apply choice as a usage decision, and no comparison to siblings such as marketplace_set_discount or marketplace_set_publication. The only guidance is the availability note ('Internal API; disabled by default').

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, idempotentHint=false and destructiveHint=false, so the mutation/non-idempotent profile is covered. The description adds genuinely new context (internal API, disabled by default), which is valuable, but it does not disclose the effect of clearing the timestamp, the need for confirmation, or reversibility.

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

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

Two compact sentences with the core action front-loaded and the operational caveat trailing. No wasted words, though the brevity is partly why parameter coverage 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?

For a non-idempotent mutation with no output schema and 0% parameter documentation, the description is too thin. It omits confirmation semantics, the set-vs-clear distinction (null moderated_at), and any indication of what happens on success or failure.

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

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

Schema description coverage is 0%, so the description carries the full burden. It clarifies moderated_at as a publication timestamp and hints at the plan/apply mode, but application_id and especially confirmation are entirely undocumented, leaving most of the 4 parameters opaque.

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 pair (plan/set/clear) and the target resource (the internal moderated_at publication timestamp). It is clear what the tool manipulates, though it does not explicitly position itself against siblings like marketplace_submit_for_moderation.

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?

'Plan or set/clear' implies a plan-then-apply workflow and 'Internal API; disabled by default' flags that it may be unavailable, giving implied usage context. However, it names no alternatives and gives no explicit condition for choosing plan vs apply beyond the enum.

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 'disabled by default' caveat is genuine behavioral context not carried by the annotations, and 'Internal API' scopes who should use it. But it doesn't explain the plan/apply dry-run behavior, what the confirmation parameter gates, or whether an update overwrites existing offer fields—all meaningful for an idempotentHint=false, openWorldHint=true mutation.

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

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

Two tight sentences, front-loaded with the core action before the availability caveat. Efficient, though it is arguably terse rather than fully economical given the complexity it skips.

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

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

This is a complex mutation with a nested required payload, 0% parameter documentation, and no output schema. The description leaves the mode semantics, offer_id usage, and confirmation gating entirely unexplained, so an agent cannot confidently invoke it correctly.

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

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

Schema description coverage is 0% across 4 parameters including a nested object with 9 required fields. The description never names mode's enum values (plan/apply), the role of the optional offer_id (update vs create), or the purpose of confirmation, so it fails to compensate for the empty schema docs.

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 ('create/update an internal Marketplace special offer') and the 'upsert' semantics are clear, distinguishing it from siblings like delete_offer and list_offers. It falls short of a 5 only because it doesn't fully articulate the create-vs-update branch that the sibling set implies.

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?

'Plan or create/update' hints that mode selects between a dry-run and a write, and 'Internal API; disabled by default' warns about availability. However, there is no explicit statement of when to choose upsert over creating/updating elsewhere, nor when not to call it.

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

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

The description asserts 'Creation is naturally idempotent by slug within the developer account,' while the annotations explicitly declare idempotentHint=false. This is a direct conflict on retry semantics, and it also omits any statement of required permissions or side effects of the apply mode.

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

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

Two short sentences, front-loaded with the primary action and no filler. It is economical, though the second sentence spends its budget on a claim that conflicts with the annotations.

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 high-complexity mutation tool with a deeply nested object, no output schema, and only bare annotations, the description should explain mode semantics, required auth, and what a draft creation returns. It leaves all of that unaddressed.

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 3 parameters, one of which is a large nested application object with 17 required fields. The phrase 'by slug' usefully signals slug as the identity key, but mode and partner_id are never explained and the nested object is entirely undocumented in prose.

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 pair (plan/create) and resource (draft Marketplace application), which maps cleanly to the plan/apply mode enum and distinguishes it from update_application or submit_for_moderation. It is clear but does not explicitly name a sibling it supersedes.

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?

'Plan or create' implies that plan is a preview path and apply is the write path, but the description never explains when to use which mode, nor when this tool is preferred over marketplace_update_application. Usage is only inferable from the verb choice.

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

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

Annotations already disclose the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds a genuinely useful behavioral note that the upstream partner token is redacted from the response, but it omits the implications of non-idempotency and whether 'plan' is a safe dry-run.

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

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

Two short sentences, zero filler, with the core action front-loaded and the redaction caveat as a compact follow-up. Nothing is padded.

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 non-idempotent, open-world mutation tool with a nested required object and no output schema, the description is thin: it omits mode semantics, field expectations, permission requirements, and what 'plan' returns relative to 'apply'. The single redaction note does not cover these 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 description coverage is 0%, and the schema exposes a nested 'account' object with eight properties (name, email, phone, title, legal_type, description, website_url, partner_token) that are entirely undocumented anywhere. The description only faintly implies the mode enum via 'Plan or create' and gives no field-level semantics.

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 ('Plan or create a developer account'), which is clear enough to distinguish it from siblings like update/delete_developer_account. However, it leaves the meaning of 'plan' vs 'create' and their mapping to the mode enum implicit, so the precise operation is still somewhat 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 use this tool versus siblings such as marketplace_update_developer_account or marketplace_create_application. Critically, it never explains when to use mode='plan' versus mode='apply', which is the central decision an agent must make before calling.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds the non-obvious side effect that deletion may orphan a management workflow, which is genuine extra context. However, it omits the plan/apply mode workflow and the confirmation parameter entirely, which are significant behavioral facts for a destructive op.

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 core action front-loaded and zero padding. It is efficient, though the brevity borders on under-specification rather than pure conciseness.

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

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

This is a destructive operation with a two-stage plan/apply workflow, no output schema, and 0% schema description coverage, which places the full explanatory burden on the description. The description covers only the action and one side effect, leaving mode semantics, confirmation, and irreversibility details unaddressed.

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

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

Schema description coverage is 0% and all three parameters are undocumented. The description never mentions the plan/apply mode enum, partner_id, or the confirmation string, so an agent has no way to know the call may be a dry-run or an applied deletion without reading the raw schema.

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

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

The description gives a specific verb+resource ("Delete a developer account") that cleanly distinguishes it from siblings like create_developer_account, update_developer_account, and list_developer_accounts. It stops short of explicitly naming or ruling out any alternative, but the purpose 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?

There is no statement of when to use this tool versus update_developer_account or any other sibling, and no prerequisites are described. "May orphan its management workflow" is a consequence, not usage guidance, so the agent gets no routing or precondition information.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds meaningful context beyond that: results are restricted to callers who own the application and are drawn from the authoritative developer-account list. It says nothing about error behavior or what happens for non-owned IDs.

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

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

One tight sentence with the verb and resource front-loaded and no filler. The phrase 'authoritative developer-account application list' is slightly abstract but still carries scoping 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 two-parameter read with no output schema, the description conveys the core retrieval semantics and ownership scoping, and annotations carry the safety profile. It remains ambiguous versus the very similar backoffice_get_application sibling, which is the main missing differentiator.

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%: partner_id is documented in the schema as the developer account used for ownership checks, while application_id has no description. The description's mention of 'owned' and the developer-account list loosely reinforces partner_id's role but adds no format or constraint detail, so it roughly matches the baseline for partial 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?

States a specific verb ('Get') and resource ('one owned application') plus the retrieval mechanism (filtering the developer-account application list). It implicitly scopes to caller-owned apps, which helps separate it from list_ applications. It does not, however, distinguish itself from the close sibling marketplace_backoffice_get_application.

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 word 'owned' implies the caller must have ownership and that a partner/developer account is involved, so usage context is implied rather than stated. There is no explicit when-to-use/when-not or pointer to the backoffice variant or list_applications as an alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered by structured data. The description contributes the content of the payload (categories, channels, functionalities, country dictionary), but adds nothing on permissions, caching/staleness, or rate limits despite being an openWorldHint tool.

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

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

A single front-loaded sentence that names the resource first and then enumerates the returned data. No filler, no repetition of the tool name, and every clause carries 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 output schema and no parameters, the description carries the burden of describing what is returned, and it does so by listing the four data families. It stops short of describing the shape of those structures (e.g. whether country IDs are ISO codes), which would fully close the 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?

The tool takes zero parameters, which is the baseline-4 case per the rubric. The description correctly implies a parameterless call and adds no misleading parameter information.

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

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

The description pairs a specific verb ("Get") with a named resource ("Marketplace catalog metadata") and enumerates the references returned: categories, channels, functionalities, and a country dictionary. It is clearly distinguishable from the sibling tools, which all operate on applications, developers, offers, or payments rather than static catalog/reference data, though it does not explicitly name a sibling.

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

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

Usage is only implied: an agent can infer this is the tool for fetching reference/catalog lists, but there is no explicit statement of when to call it (e.g. before mapping country IDs) and no when-not guidance or named alternatives. Since no sibling competes for this data, the omission is minor but still a gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only that results include both application and category-average series; it says nothing about how date ranges or granularity roll up, data freshness, rate limits, or result size, which are the behaviors an agent would need here.

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 efficient sentence with no filler and the resource front-loaded. It is concise but arguably too terse given the parameter complexity it leaves unexplained.

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 six required parameters, a non-obvious conversion enum, low schema coverage, and no output schema, the definition is materially incomplete. An agent cannot tell what a returned 'series' contains, how the funnel conversions are keyed, or how date_from/date_to and granularity interact.

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 17% (just partner_id), yet the description never explains any of the six required parameters. The 'conversion' enum values (open_pending, pending_active, etc.) and the granularity/date-range semantics are left entirely undocumented, 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 uses a specific verb ('Get') and a well-defined resource ('Marketplace funnel conversion series'), and clarifies that the series covers both application-level and category-average data. It does not distinguish itself from the close sibling marketplace_get_statistics, 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?

There is no guidance on when to use this tool rather than marketplace_get_statistics or the other statistics/list siblings, and no prerequisites (scope, permissions, or data availability) are mentioned. Usage must be inferred 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 declare readOnlyHint, idempotentHint, and non-destructive behavior, so safety is covered. The description adds that the response bundles status, payments, and a transition log, which is useful given there is no output schema, but it does not cover auth/ownership failure behavior or the shape of the returned data.

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 scope qualifier 'at one location' lands cleanly. It is efficient, though one more clause on the read semantics would have earned full marks.

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 does mention the returned elements, which is helpful, but it leaves two of three parameters undocumented and says nothing about failure modes or data format, leaving an agent short of fully armed for this 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 coverage is only 33%: partner_id is documented as the ownership-check account ID, but application_id and location_id have no description. The tool description adds no meaning for any parameter, 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 states a specific verb ('Get') and the concrete payload (status, payments, status-transition log) scoped to an owned application at one location, which clearly separates it from siblings like list_installations or activate_installation. It is clear but does not explicitly name a sibling alternative the agent should consider.

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/when-not guidance and no named alternative. The agent must infer that this is the read path for a single installation's state versus activate_installation, uninstall, or list_installations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful scoping fact that the link targets an installed location, but says nothing about link lifetime, single-use behavior, or whether the returned link creates any server-side state.

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 sentence, no filler, and the distinguishing scope ('for an installed location') is front-loaded. Nothing 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?

Five required parameters, 20% schema coverage, no output schema, no annotations explaining return shape, and no usage guidance — yet the description is a single clause. An agent still would not know what the link is for, when it expires, or how discount affects 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 only 20% (just partner_id), and the description adds zero parameter meaning for application_id, location_id, tariff_option_id, or discount, all required. The semantics of 'discount' (percent 0-100 per schema) are never connected to the generated link.

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+resource ('Generate an Altegio-hosted Marketplace payment link') and scopes it to 'an installed location', which separates it from sibling write-payment tools like marketplace_record_payment and marketplace_refund_payment. Minor friction: the tool name says 'get_' while the description says 'Generate'.

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 call this versus adjacent tools (record_payment, refund_payment) or what precondition must hold beyond the implicit 'installed location'. No exclusions, no sequencing, no mention of when the link should be discarded.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds the useful scope detail that it applies to owned applications and requires a date range, but says nothing about auth/ownership enforcement, aggregation behavior, or result granularity.

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 wasted words; the enumerated metrics are packed efficiently. It is well-structured, though the terseness contributes to the missing usage and parameter 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?

Without an output schema, the description helpfully names the metrics returned, which partly compensates. But with four required parameters, only 25% schema coverage, and an adjacent near-identical sibling, the definition omits enough routing and parameter context to be only minimally adequate.

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

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

Schema description coverage is only 25% – just partner_id is documented. date_from, date_to, and application_id carry no descriptions, and the description only vaguely gestures at 'a date range' without explaining the YYYY-MM-DD format implied by the pattern or the role of application_id/partner_id in scoping the query.

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 ('Get') and resource ('statistics') and enumerates the exact metrics returned: views, pending grants, activations, new payments, uninstalls. However, it does not distinguish itself from the sibling marketplace_get_conversion_statistics, leaving the agent to guess which statistics endpoint to pick.

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 when not to use it. The presence of the sibling marketplace_get_conversion_statistics makes the absence of any routing rule a real gap, since two 'get statistics' tools coexist without differentiation.

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

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

Beyond the annotations (not read-only, not destructive, not idempotent, openWorld), the description discloses the resulting state — 'pending (or immediate active for eligible draft/private apps)' — and the 'exact confirmation' requirement for apply, which is genuine behavioral context. It stops short of describing failure modes or auth specifics.

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 dense sentences, front-loaded with the core action and scope. No filler, though the parenthetical makes the second sentence slightly heavier than necessary.

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

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

For a 5-parameter mutation tool with no output schema, the description covers the state outcome and confirmation gate reasonably. It leaves open what the confirmation value must be (only 'exact' is stated) and what a 'plan' result looks like, which are meaningful 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 only 20%, so the description carries the burden. It partially compensates by explaining the mode dichotomy (plan/apply) and the confirmation requirement, and location/application semantics are inferable from 'location owner grants access' and 'installation.' But location_id and application_id remain undocumented beyond inference.

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+resource (location owner grants access) and frames it as 'step 1 of installation,' which situates it relative to activate_installation and install_sidebar_frame. It is clear but does not explicitly contrast itself against sibling lifecycle tools, so it falls short of a 5.

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

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

It implies this is the first step of an installation flow and flags that 'apply requires exact confirmation,' giving some context. However, it never states when to choose plan vs. apply, or when a sibling like activate_installation would be the right call instead. Usage is implied rather than explicit.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), but the description adds almost no behavioral context beyond restating mutation. Critically it never explains that the required 'mode' includes a 'plan' dry-run versus 'apply' commit, nor the meaning of the 'confirmation' parameter or ownership checks.

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, no filler, with the action front-loaded ahead of the type-scope clarification. Efficient for what it does, though brevity here comes partly from under-specification.

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 7-parameter, 6-required mutation tool with 14% schema coverage and no output schema, the description is too thin. An agent is left without enough to correctly invoke plan vs apply mode, supply confirmation, or understand the url/applications/location bindings.

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 14% (just partner_id), so the description must compensate heavily. It maps the three values of the 'type' enum (chat/waiting_list/task_tracker) but leaves the plan/apply semantics of 'mode', the purpose of 'confirmation', and the roles of url/application_id/location_id entirely 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 pair (install/remove) and resource (sidebar frame), and enumerates the three handled types. It also disambiguates from developer employee/client/visit frames, which helps separate it from the entity-frame siblings, though it does not name those tools directly.

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

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

No explicit when-to-use or when-not guidance is given, and no alternative sibling (e.g. marketplace_replace_entity_frames, marketplace_list_entity_frames, marketplace_toggle_sidebar_highlight) is named for routing. The type distinction is a scope statement rather than usage direction.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds a genuinely useful behavioral trait beyond those: 'Secret fields are redacted', telling the agent that returned data is partially masked. It does not discuss pagination or result size, so it falls short of 5.

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

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

Two sentences, front-loaded with the action and scope, followed by the returned fields and the redaction caveat. No filler or redundancy; every phrase earns its place.

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

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

No output schema exists, and the description compensates by enumerating the main returned fields and noting redaction. It omits pagination/result-size behavior, but for a straightforward read-only list tool this is a minor gap.

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

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

Schema coverage is 0% and the single parameter partner_id is never named, so the schema does not compensate. The phrase 'in a developer account' implicitly scopes the query to an account identifier, partially mapping to partner_id, but no type, format, or meaning is added explicitly.

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 ('List applications in a developer account') and enumerates what each item contains (card configuration, permissions, system-user ID, short links, moderation state). The plural 'list' distinguishes it from the singular marketplace_get_application, but no sibling is named 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 scope 'in a developer account' implies when to use it (enumerating apps for an account), but there is no explicit when-to-use vs when-not, no mention of the alternative single-app retrieval (marketplace_get_application), and no prerequisites 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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that the data is 'current' and 'hierarchical', which is mild context, but it omits the return structure and the role that partner_id plays in scoping the result.

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

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

A single front-loaded sentence that names the resource first with no filler. Efficient, though the terseness comes partly from missing information rather than disciplined editing.

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

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

For a simple read-only lookup with no output schema and one required parameter, the description is minimally adequate. However, it leaves the meaning of partner_id and the shape of the returned 'dictionary' entirely unexplained, which an agent would need to call it correctly.

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

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

Schema description coverage is 0% and there is one parameter (partner_id) that the description never mentions. The description does not compensate for the coverage gap by explaining whose partner_id scopes the rights or what values are valid.

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 ('Return') and resource ('hierarchical permission dictionary available to Marketplace system users'), so an agent knows it retrieves a permission structure. It is clear on its own but does not differentiate itself from any sibling (none returns rights), 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 when-to-use, when-not-to-use, or alternative guidance is given. The phrase 'available to Marketplace system users' hints at scope but does not tell the agent when this lookup is appropriate versus other marketplace tools that also return configuration data.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds one genuine behavioral detail beyond that — that secret fields in partner-system metadata are redacted — but says nothing about pagination, ordering, or result volume for what is clearly a collection-returning call.

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, with the primary purpose front-loaded and the redaction caveat trailing it. Every clause earns its place.

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

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

With no input params and no output schema, the description carries the descriptive burden and does cover scope and the redaction behavior. It stops short of mentioning pagination or the general shape of what is returned, which matters for an open-world list tool, but it is largely adequate for an agent to call it correctly.

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

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

The tool takes no parameters, so there is no parameter semantics for the description to explain; the schema is trivially complete. Baseline 4 applies for a zero-parameter tool.

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

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

States a specific verb and resource (list developer accounts) plus an ownership scope (owned by the current Altegio user), which distinguishes it from sibling mutations like create_developer_account, update_developer_account and delete_developer_account. It does not, however, contrast itself with other listing tools (e.g., marketplace_list_applications), so the differentiation is implicit 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 description never says when to reach for this tool versus the many sibling listing/get tools, nor does it mention prerequisites such as owning a developer account. Usage is only inferable from the name and the ownership phrasing; no explicit when-to-use or when-not-to-use guidance is 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, idempotentHint and non-destructive, so safety is covered. The description adds genuinely new behavioral context: declarations are only copied to a location during a later application installation, which tells the agent these frames are inert definitions rather than active runtime entities.

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, front-loaded sentences with no padding; the purpose comes first and the lifecycle caveat second. The phrase 'a location' is slightly vague but does not harm brevity.

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 carries the burden of explaining what is returned, and it only says 'definitions' without indicating the shape of an entity frame. Combined with the undocumented application_id, the definition is adequate but leaves real gaps for an agent trying to call it correctly.

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

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

Schema coverage is only 50%: partner_id is documented as the developer account used for caller ownership checks, but application_id has no description anywhere. The tool description says nothing about either parameter, so it fails to compensate for the schema 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?

States a specific verb (List) and resource (declared employee/client/visit iframe definitions) scoped to an application. It implicitly separates 'declared' frames from the installed copies handled by siblings like marketplace_install_sidebar_frame and marketplace_replace_entity_frames, but never names those siblings or states the distinction 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?

There is no explicit when-to-use guidance, no conditions, and no reference to the closely related replace_entity_frames or install_sidebar_frame tools. The lifecycle sentence hints that declarations exist before installation, but an agent is left to infer whether this is the read-side counterpart to replace_entity_frames.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The only added trait, 'bounded pagination', is essentially a restatement of the count maximum=1000 constraint already in the schema, and it does not explain page/count interaction or what 'locations' records contain.

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 wasted words. It is efficient, though the brevity is partly achieved by omitting information the agent needs rather than by tight editing.

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 required-4-param, mutating-free but ownership-checked query with no output schema and 25% parameter coverage, the description omits prerequisites (partner_id ownership check is in the schema, not the description), pagination semantics, and return content. An agent could construct a call but would be guessing about scope and results.

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 25% (only partner_id is documented), so the description carries the burden of explaining page, count and application_id semantics. It says nothing about any of them, and 'bounded pagination' is too vague to compensate for the undocumented page/count behavior.

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 concrete verb ('List') and a resource ('locations connected to an owned application'), but it uses 'locations' while the tool name says 'installations', leaving the agent to guess whether these are the same concept. It does not differentiate itself from the many sibling list tools (list_applications, list_developer_accounts, list_offers).

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 rather than marketplace_get_installation_status, marketplace_list_applications, or the backoffice list tools. The 'owned application' qualifier hints at a scope condition but it is never stated as a routing rule or prerequisite.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description adds only that returned reviews are 'public', and says nothing about pagination behavior or result ordering despite a required page parameter.

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. It is efficient, though the brevity contributes to the missing pagination and parameter detail rather than compensating for it.

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 list tool with no output schema, the safety profile is covered by annotations, but the required page parameter and the shape/ordering of results are left entirely undocumented.

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 carry the burden, but it explains neither application_id (which application) nor page (pagination semantics, page size, limits). Only the bare intent is conveyed.

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 (public reviews) scoped to a Marketplace application. It is unambiguous, though the distinction from siblings is not needed since no sibling lists reviews.

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 e.g. marketplace_get_application, nor any prerequisite or exclusion. The word 'public' is the only implied scoping signal.

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

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

Annotations already cover readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is established. The description adds only the implicit ownership scoping and says nothing about pagination, result size, or the tariff data returned, so it is minimally valuable beyond the annotations.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably under-specified rather than 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 a two-parameter read-only list tool with no output schema, the description is thin: it never indicates what a tariff record contains or whether results are paged. Annotation coverage of the safety profile offsets some of this, but the description leaves the caller guessing about output 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 description coverage is 50%: partner_id is documented as the developer account ID for ownership checks, but application_id has no description. The description's 'owned application' phrase only loosely gestures at application_id and adds no format or constraint detail 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?

States a specific verb (List) and resource (Marketplace billing tariffs and options) and scopes it to an owned application. It is distinguishable from sibling list tools by the 'billing tariffs' resource, though it does not explicitly contrast itself with any sibling.

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, when-not-to-use, or alternative named. The phrase 'for an owned application' hints at a precondition but never states the ownership requirement or what to call instead for unowned apps.

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 it is not read-only, is open-world and non-idempotent. The description usefully adds that it may trigger side effects (notifications/leads) dependent on location settings, which goes beyond the annotations, but it does not explain the plan/apply distinction or 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?

A single tight sentence with the action front-loaded and no filler. Appropriately sized, though it is arguably too terse given the tool's complexity.

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

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

For a tool with 7 required parameters, a plan/apply mode, no output schema, and only 14% schema coverage, the description is far too thin. It omits mode semantics, parameter meaning, and the mechanics of the notification/lead side effects, leaving an agent without enough to call it correctly.

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

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

Schema description coverage is only 14% across 7 required parameters, so the schema is largely silent. The description compensates for none of this: it never mentions mode, partner_id, application_id, phone_from, message, or name, only vaguely alluding to 'location settings'. The undocumented parameters remain 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 names a specific verb and resource ('Signal a new chat message') and states the effect (highlights the chat frame, may create notifications/leads). It is clear what the tool does, though it does not explicitly distinguish itself from any sibling tool.

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

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

There is no guidance on when to call this versus alternatives, nor any prerequisites. The presence of a plan/apply mode parameter but no explanation of when to use which mode leaves usage 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?

Adds real context beyond the annotations: the unfreeze side effect (not implied by destructiveHint=false), the durability requirement on the idempotency key, and the need for 'exact confirmation'. Note the description's idempotency emphasis sits in tension with idempotentHint=false, though the explicit key parameter makes it a benign distinction rather than a contradiction. It still does not say what happens on a failed/mismatched confirmation or what the response 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?

Three short front-loaded sentences with no filler; the core action leads and the consequences follow. Each sentence earns its place, though the second and third drift between side effects and input requirements rather than grouping them.

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 11 parameters at 9% schema coverage and no output schema, the description is too thin: the plan/apply mode distinction (the single most important invocation decision) is never explained, nor is the required-vs-optional status of confirmation. An agent has enough to know what the tool is for but not enough to call it correctly.

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

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

Schema description coverage is only 9% across 11 parameters, so the schema carries almost no semantics. The description mentions only the idempotency key and confirmation, leaving mode (plan vs apply), payment_sum, currency, and the payment_date/period_from/period_to temporal relationships unexplained. It also fails to flag that confirmation is optional in the schema despite being described as required.

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 pair ('record a successful external payment') and covers both operating modes ('Plan or record'), which is clear enough to separate it from siblings like refund_payment or get_payment_link. However, it never names an alternative tool, so the differentiation is inferred from the money-handling context 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 description implies usage through 'Plan or record' and the side-effect note 'This can unfreeze an installation', so an agent can infer that this is the path to restore a frozen install. It gives no explicit when-not guidance, no prerequisites, and no reference to refund_payment or get_payment_link as alternatives.

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

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

Annotations already disclose destructiveHint=true, readOnlyHint=false, openWorldHint=true and non-idempotence, so the safety profile is largely covered. The description adds one genuinely useful behavioral constraint beyond that – the exact confirmation phrase gating the operation – but omits what gets destroyed, permission requirements, and whether plan mode mutates anything. Note the tension: confirmation is optional in the schema though the description calls it required.

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 action and followed by the key constraint. No filler, though it is arguably under-written for a destructive 5-parameter tool rather than merely concise.

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

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

For a destructive, non-idempotent payment tool with 5 parameters, 20% schema coverage and no output schema, the description is too thin: it omits the plan/apply workflow, the confirmation phrase value, caller-ownership requirements for partner_id, and any notion of what a refund does to existing state.

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 20%, so the description must compensate and does not: partner_id, application_id and payment_id get no explanation, and the enum is plan/apply while the prose says "plan or report," a mismatch that could confuse mode selection. Only the confirmation parameter gains any meaning from the text.

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 (refund) and resource (Marketplace payment) and flags a dual plan/apply capability, so an agent knows exactly what this does. It does not differentiate itself from the closest sibling, marketplace_record_payment, or clarify how the two relate (e.g. refund as reversal of a recorded payment).

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?

"Plan or report" implies a two-step workflow and the requirement of an exact confirmation phrase gives a precondition, which is useful guidance. However, it never states when to use plan vs apply, when this tool should be chosen over marketplace_record_payment, or that confirmation is only needed in apply mode.

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 destructiveHint=true, idempotentHint=false and openWorldHint=true. The description adds genuinely new and critical behavior beyond that: omitted slugs are deleted, and existing installations are not updated or backfilled. It stops short of explaining the confirmation requirement or mode-dependent effects.

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

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

Three short sentences, zero filler, with the replace semantics and destructive deletion rule front-loaded. Every sentence earns its place.

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

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

For a destructive, non-idempotent, no-output-schema tool, the description covers the core side effects but omits the confirmation parameter (which is presumably required for the apply path) and any statement of what the plan mode returns or how apply is authorized. Enough to proceed cautiously, not enough to invoke confidently.

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

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

Schema coverage is only 20%, so the description carries most of the burden. It clarifies frames semantics (omitted slugs are deleted) and loosely maps to the plan/apply mode enum, but says nothing about partner_id, application_id, or the confirmation parameter, leaving several required inputs 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 action (plan or replace) on a specific resource (the full employee/client/visit declaration set), and the slug names make the resource concrete. An agent can distinguish it from the sibling marketplace_list_entity_frames, though the description 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?

"Plan or replace" hints at a two-mode workflow but never says when to use plan versus apply, nor what precondition (e.g. a prior plan run, confirmation) must hold. Usage is implied rather than stated, and 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds almost no behavioral detail: it doesn't say whether apply-mode persists state, whether repeated saves overwrite prior instructions, or what permissions partner_id checks require.

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 efficient sentence with no filler, front-loading the action and its object. It could be slightly better structured by explicitly tying 'plan'/'save' to the mode enum, but it wastes no words.

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

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

This is a five-required-parameter mutation tool with no output schema and sparse schema descriptions, and the description does not fill the gap. The critical ambiguity of the plan/apply mode and the two ID parameters is left entirely to the caller.

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 20% (only partner_id is documented), so the description must carry the load. It weakly implies connect_instruction, payment_instruction, and a mode choice, but leaves partner_id, application_id, the maxLength constraints, and the semantics of plan vs apply 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 names a specific verb pair (plan/save) and concrete resources (connection and payment instructions), and it positions the tool relative to the sibling submit-for-moderation step. It is clear what the tool acts on, though 'plan' vs 'save' mapping to the plan/apply enum is left implicit.

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

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

The phrase 'before submitting an application for moderation' implies the timing/context, but there is no explicit guidance on when to use this versus marketplace_submit_for_moderation, nor on the plan-vs-apply distinction. 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 declare a non-read-only, non-idempotent, open-world mutation, and the description adds nothing beyond that: it doesn't say what 'plan' returns versus 'apply', what gets mutated, or whether apply is irreversible. The presence of an undocumented 'confirmation' parameter strongly suggests a guarded write step that the description never explains.

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

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

A single sentence with no filler and the resource is front-loaded, so there is no waste. However, brevity here is under-specification rather than conciseness for a six-parameter mutation tool.

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

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

Given five required parameters, a low-coverage schema, an undescribed confirmation parameter, and no output schema, this one-liner leaves an agent unable to safely invoke the tool. It should at minimum explain the plan/apply two-step and the confirmation requirement.

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 17%, so the description must compensate and it does not. It hints at 'discount' and 'selected locations' (location_ids) and implies the mode, but says nothing about partner_id, application_id, or the unexplained 'confirmation' parameter, which is likely required for the apply path.

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 ('Plan or set') and resource ('Marketplace payment discount') with a scope qualifier ('for selected locations'). No sibling tool deals with discounts, so differentiation is not a problem, but the plan-vs-apply distinction is left implicit.

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 mention of prerequisites (partner_id is described in the schema as an ownership check), and no explanation of when to choose 'plan' versus 'apply'. The two-mode workflow is the core usage decision and it is never addressed.

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 the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds only the plan/publish duality and the 1-20 bound; it omits whether apply is reversible, what plan returns, and what authorization (partner ownership) is needed for a mutation that publishes sender names.

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 core action front-loaded and no filler. It is efficient, though its brevity is part of the completeness problem rather than a virtue.

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 5-required-parameter mutation with 20% schema coverage and no output schema, one sentence is not enough. The agent lacks permission requirements, the plan-vs-apply return difference, and semantics for location_id/application_id.

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 20% (just partner_id), so the description must compensate and largely does not. It echoes 'plan or publish' for mode and '1-20' for short_names, but both facts already exist in the enum and min/maxItems, while location_id and application_id remain undocumented 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 states a specific verb ('Plan or publish'), a resource ('SMS sender names'), and scoping ('1-20 ... for a compatible installed application'). This distinguishes it adequately from the sibling list, which contains no other SMS-sender tool, though it does not explicitly name a sibling it is not.

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?

'Plan or publish' hints that a dry-run versus real-publish distinction exists, but the description never says when to choose plan over apply nor names any alternative or prerequisite. Usage is left almost entirely to inference from the mode enum.

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, idempotentHint=false, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that: it doesn't explain that apply triggers an irreversible moderation workflow, what the 'confirmation' parameter is for, or what side effects occur.

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

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

A single front-loaded sentence with no filler, with the dual-mode nature surfaced first. It is efficient, though its brevity tips into under-specification rather than true conciseness.

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

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

For a four-parameter mutation tool with no output schema and only 25% schema coverage, the description is far too thin. Nothing explains the required vs optional parameters, the confirmation flow, or the moderation outcome the caller should expect.

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

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

Schema description coverage is only 25% (only partner_id is documented). The description does not mention mode, application_id, or the entirely undocumented 'confirmation' parameter, which is the parameter most likely to gate a real submission and therefore most in need of explanation.

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 ('Plan or submit') and resource ('a fully configured application for Marketplace moderation'), so the agent knows this is the moderation-submission entry point. It does not distinguish itself from adjacent siblings such as marketplace_save_moderation_instructions or marketplace_backoffice_set_publication, leaving some ambiguity about boundaries.

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?

'Plan or submit' hints at the plan/apply enum but never states when to use a dry-run plan versus an actual submission, nor does it mention prerequisites (a fully configured application) or what happens after submission. No alternatives 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 cover the safety profile (readOnly=false, destructive=false, idempotent=false, openWorld=true) and the description does not contradict them. It adds the useful frame-already-installed precondition, but omits the most behaviorally significant fact: that the mode enum selects a dry-run (plan) versus a real mutation (apply).

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, and the action plus scope come first. It is efficient but undersized for the amount of undocumented behavior it must carry.

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 7-parameter mutation tool with no output schema and near-zero schema documentation, the description is far too thin. It never explains plan vs apply, the frame type selector, or ownership requirements, leaving an agent materially under-informed before calling 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 only 14%, leaving six of seven parameters undocumented in structured data. The description only illuminates user_id ("optionally for one user") and vaguely hints at is_enabled; the critical mode (plan/apply), type, and the ownership-checking partner_id remain unexplained, so the description 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 states a specific verb and resource: enabling or clearing a highlight on an installed sidebar frame, scoped optionally to one user. That is enough to distinguish it from install/entity-frame siblings, though it never names a sibling tool to reinforce 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?

"already installed" implicitly conveys a prerequisite, and "optionally for one user" hints at scoping. However, there is no explicit guidance on when to prefer this over marketplace_install_sidebar_frame or replace_entity_frames, nor on how the plan/apply mode changes the workflow.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and non-idempotency, so the safety profile is covered. The description adds one genuinely useful behavioral detail not in annotations or schema text — that an exact confirmation phrase is required — but does not explain what that phrase is, that only 'apply' is destructive, or what side effects the uninstall has.

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 action and its dual mode, followed immediately by the critical precondition. 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 destructive, non-idempotent mutation with five parameters at 20% schema coverage and no output schema, the description is thin: it omits the confirmation phrase format, the plan/apply distinction's consequences, and any ownership/location constraints, leaving an agent under-equipped to call it 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 only 20% (just partner_id), leaving mode, location_id, application_id, and confirmation undocumented in the schema. The description indirectly implies mode semantics ('plan or uninstall') and flags the confirmation requirement, but never states the required phrase format or the roles of the id parameters, so it only partially compensates 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 names a specific verb and resource ('uninstall an application from a location') and distinguishes the two operating modes (plan vs. actual uninstall). It's clearly differentiated from siblings like marketplace_activate_installation or marketplace_install_sidebar_frame, though it never explicitly names an 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?

The phrase 'Plan or uninstall' implies a two-step flow (dry-run then apply), which hints at when each mode is appropriate, but there is no explicit guidance on sequencing, prerequisites, or when to prefer this tool over related lifecycle tools such as activate_installation.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, but the description adds non-obvious behavior: omitted collections are cleared on apply, and an exact confirmation is required. That clearing/confirmation detail is exactly the kind of context 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 tightly written sentences with no filler, front-loading the destructive semantics and the confirmation requirement. Efficient, though it could spend one clause on the plan/apply distinction it introduces.

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

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

For a complex nested-replace tool with no output schema, the description covers the critical destructive/confirmation caveat but omits what 'plan' returns, whether apply is reversible, and ownership-check behavior. Adequate but with clear gaps against the tool's 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?

Schema description coverage is only 20% (only partner_id is documented), and the description does not compensate: partner_id, application_id, and the large application object's many required fields are unexplained. Only 'confirmation' gains any meaning from the description's reference to exact confirmation.

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 pair ('Plan or replace') and resource ('complete Marketplace card and technical settings'), distinguishing it from create/delete/upsert siblings. It does not explicitly contrast with marketplace_create_application or set_publication, so file-level sibling differentiation is left implicit.

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 mention of 'plan' vs 'apply' implies the two-phase workflow, but the description never says when to choose this tool over marketplace_create_application or the set_* siblings. Usage is inferable from the mode enum 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 non-readOnly, non-destructive, non-idempotent, open-world behavior. The description adds a genuinely useful behavioral trait beyond them: this is a full replacement requiring 'the complete current account payload', warning the agent that partial updates are not allowed. It stops short of noting reversibility or side effects, so not a 5.

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

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

Two short sentences, front-loaded with the operation and immediately followed by the key payload constraint. No wasted words, though it is terse to the point of under-covering.

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 nested object, 7 required account fields, a plan/apply enum, and no output schema, the description leaves major gaps: it never explains plan vs apply semantics, partner_id, or what a plan-mode call returns. It is inadequate for the tool's 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?

Schema description coverage is 0%, so the schema does not carry parameter meaning, and the description does almost nothing to compensate. It never explains mode's plan/apply enum, partner_id, or the nested account fields, beyond the vague 'complete current account 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?

States a specific verb ('replace'/'plan') and resource ('developer-account details'), which is clear enough to identify the operation. However, it does not distinguish itself from siblings like marketplace_create_developer_account or marketplace_update_application, leaving differentiation to inference.

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

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

There is no explicit when-to-use guidance, no mention of the plan-vs-apply mode distinction, and no routing to alternatives. The word 'Plan or replace' hints at a two-phase flow but never explains which to pick or 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 declare readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the description carries less burden, yet it discloses nothing extra. The critical unknown for a non-idempotent mutation is what 'plan' does versus 'apply' (dry-run vs commit), and the description does not say, nor does it mention reversibility or side effects on the location's channel config.

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 efficient sentence with the operation front-loaded and zero filler. It is well-formed prose; it is simply under-specified rather than bloated.

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 6-required-parameter mutation with no output schema, low schema coverage, and a two-valued mode controlling dry-run versus commit behavior, one sentence is inadequate. An agent cannot safely choose a mode or predict the effect of the call from this description.

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 17% (only partner_id is documented), so the description must compensate for 6 required parameters and it does not. The meaning of 'apply' vs 'plan', the effect of is_available, and the role of location_id/application_id are left entirely to inference.

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 pair ('Plan or update') and a concrete resource ('SMS/WhatsApp channel availability'), plus a scoping constraint ('compatible installed application'). It is more specific than the tool name alone, though 'plan or update' does not clarify which of the two modes it maps to, and there is no differentiation from siblings like marketplace_set_sms_sender_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 indication of when to use this tool versus the many sibling marketplace tools, nor when to prefer one mode over the other. The plan/apply distinction in the required 'mode' enum is exactly the guidance an agent needs, and it is absent.

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

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

Annotations already declare the safety profile (readOnly, idempotent, non-destructive, open world), so the bar is lower. The description does add one genuine behavioral fact – the token is checked 'without revealing it' – but omits what happens on a failed validation, whether errors leak token material, and what the normalized output 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?

A single front-loaded sentence with no filler; the verb, the resource, and the token constraint are all packed efficiently. It is a little dense and could have spent one more clause on the return behavior without bloat.

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

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

For a tool whose input is a discriminated union of two payload shapes and which has no output schema, the description is only partly sufficient: purpose and event types are covered, but return values, error semantics, and the meaning of partner_id are absent. 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 description coverage is 0%, so the description must carry parameter meaning and largely does not. It names the three event kinds (uninstall/freeze/payment), which maps to the payload enum, but says nothing about partner_id or the required fields of the two payload shapes, leaving most of the contract 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 pairs a specific compound verb ('validate and normalize') with a clearly bounded resource ('uninstall/freeze/payment callback payload'), so the agent can tell it apart from the CRUD/list siblings. It stops short of clarifying what the normalized result is or how it is returned, which keeps it out of the top band.

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

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

Usage is only implied: the tool is obviously meant to be invoked when a marketplace lifecycle callback arrives, but there is no explicit statement of when to call it, what precondition (a real incoming callback) is required, or what alternative to use instead. Implied-only guidance lands at 3.

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