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 genuinely new operational context: it requires PUSHNOTIF_API_KEY and costs 0 credits. It does not mention rate limits or pagination, so it stops short of 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?

Front-loads purpose and outputs, then usage guidance, then the return shape. Dense but nearly every clause carries information; the return-shape sentence is arguably the least essential given it duplicates what a caller would learn anyway, but it earns its place with no output schema present.

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

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

No output schema exists, so the description compensates by spelling out the returned JSON structure (credits_balance, orders fields, recent_ledger). Combined with auth requirements, cost, and clear usage boundaries, an agent has everything needed to call and interpret this tool.

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

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

Schema description coverage is 100% and the single order_id parameter is fully documented in the schema, including the ord_xxxx format and the omit-to-list behavior. The description itself adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (check) and resource (QRIS top-up order payment status), then enumerates the exact outputs: payment status, credit balance, ledger history, and PDF invoice URLs. It explicitly distinguishes itself from the sibling create_qris_invoice, so an agent can route correctly without opening either schema.

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

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

Gives explicit when-to-use ('verify whether a QRIS invoice ... has been paid or to audit credit usage') and when-not-to-use ('do not use it to create a new top-up invoice'), naming the alternative tool create_qris_invoice. Nothing is left to inference.

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description discloses the auth requirement (PUSHNOTIF_API_KEY), the credit/cost model (0 credits to save, 1 credit per live visitor impression), and the no-browser-permission rendering constraint. That is exactly the kind of operational context the structured fields 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?

The single paragraph is front-loaded with purpose and the sibling exclusion, then prerequisites, cost, and return shape. Every clause carries information, though the trailing return-value enumeration makes it slightly dense for a one-paragraph block.

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 ten-parameter mutation tool with no output schema, the description covers the gaps that matter: prerequisite ordering, auth key, cost per impression, sibling routing, and the return JSON keys. An agent has everything needed 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 100%, so all ten parameters including enums-in-prose (inapp_freq, inapp_style, inapp_trigger) are already documented in the schema. The description restates the style variants in prose but adds no syntax, format, or default information beyond what the schema provides, so the baseline 3 applies.

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

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

The description names a specific verb (configure and publish) and resource (on-site In-App Popup or Banner), enumerates the three rendering styles, and explicitly differentiates itself from the sibling send_push_notification. An agent can distinguish this from every other tool in the sibling list without opening a schema.

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

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

It states when to use it (promotional popups or announcements to all active website visitors), when not to use it (OS lock-screen push, with the exact alternative named), and gives a concrete prerequisite workflow (call list_apps first to obtain app_id). Nothing is left to inference.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, but the description adds real context: it requires PUSHNOTIF_API_KEY, costs 0 credits, and stores credentials encrypted. It also spells out the return shape, which matters since no output schema exists. Only minor gap is what happens on partial credential updates (one platform only).

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

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

Front-loaded with the core action, then usage, prerequisite, auth/cost, and return value in a single dense paragraph with no filler. The em-dash credential enumeration makes one sentence heavy, but 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?

For a 6-parameter mutation with no output schema, the description covers purpose, platform scoping, prerequisite, auth key, cost, idempotency, and the exact JSON return shape. An agent has everything needed to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description goes further by mapping the credential families to platforms — FCM service-account.json for Android, .p8 AuthKey/Key ID/Team ID/Bundle ID for iOS — clarifying which fields group together. It does not add format detail beyond the schema's own examples.

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 (store) and resource (native mobile push credentials for FCM/APNs) and explicitly scopes it to Android/iOS native push. It names the boundary against Web Push handled by create_app, so an agent can separate it from create_app and send_push_notification without opening either schema.

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

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

Gives an explicit when ('enabling native Android or iOS push delivery') and an explicit when-not ('do not use it for standard browser Web Push... from create_app'), plus the prerequisite to call list_apps first. Alternatives and selection conditions are fully spelled out.

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, idempotent=true, destructive=false, openWorld=true), and the description adds substantial context beyond them: PUSHNOTIF_API_KEY requirement, SSRF validation of feed URLs, deduplication by item GUID/URL, and a credit cost of 1 per delivered subscriber per new post. This is exactly the operational context an agent needs for a write tool with billing implications.

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

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

Front-loaded with the core action, then usage, prerequisites, runtime behavior, and return shape in a logical order. It is dense and runs long, but nearly every clause (auth key, SSRF, dedup, credit cost) carries decision-relevant information rather than padding.

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 supplies the return shape ({ ok, app_id, rss_enabled, rss_feed_url, rss_interval, dispatched_now, latest_item_title }), and it covers prerequisites, auth, security constraints, dedup, and billing. An agent has everything needed to call it correctly and predict the response.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters with examples and defaults. The description reiterates dispatch_now semantics and the interval/feed fields but adds no syntax or constraints the schema lacks. Baseline 3 applies when the schema does the heavy lifting.

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 (configure) plus resource (24/7 RSS/Atom/Sitemap polling) and names the secondary dispatch_now action, so an agent understands both the standing-config and immediate-trigger modes. It explicitly distinguishes itself from send_push_notification, which handles manual one-off messages.

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

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

Provides explicit when-to-use context (blog, news portal, store wanting auto-broadcast of new articles), a when-not-to-use rule with the correct alternative (send_push_notification for manual one-offs), and a prerequisite (call list_apps to obtain app_id). Nothing is left to inference.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false), the description discloses the required credential PUSHNOTIF_API_KEY, the cost (0 credits), and that a persistent record is created. Those are operationally significant facts an agent cannot derive from the annotation block.

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

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

Three sentences, front-loaded with purpose, then routing, then operational facts; every sentence carries information. It is dense and slightly long, but with no output schema present the inline return-shape 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 write tool with no output schema the description covers auth requirements, cost, persistence semantics, routing alternatives, and the returned JSON payload shape. An agent has everything needed to call it correctly and know the outcome.

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

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

Schema description coverage is 100%, so site_url's HTTPS/localhost constraint and site_name's 2-80 character range are already fully documented in the schema. The description adds no additional parameter-level syntax or format detail, so the baseline of 3 applies.

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

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

States a specific verb (register/create) plus the resource (website or mobile app under the PushNotif workspace) and the side effect (generating an ECDSA P-256 VAPID keypair). It explicitly distinguishes itself from update_app_branding and register_new_account, so an agent can select it without opening sibling schemas.

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

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

Gives an explicit when-to-use condition ('authenticated user wants to add a new website domain or app') plus two explicit when-not-to-use cases, each naming the correct alternative tool. Nothing about routing is left to inference.

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

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

Annotations cover the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true), and the description adds materially beyond them: requires PUSHNOTIF_API_KEY, creates a PENDING order valid for 30 minutes, and credits are non-expiring and only granted on payment webhook confirmation. That lifecycle and credential detail is not derivable from 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?

Front-loads purpose, then usage routing, then credentials/lifecycle, then return shape — a well-ordered single paragraph. It is somewhat dense and repeats the package pricing already in the schema, so a small amount of text does not earn 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 no-required-param mutation tool with no output schema, the description supplies everything an agent needs: auth requirement, order lifecycle and expiry, when credits land, and an inline return shape ({ ok, order: {...} }). Nothing critical is left to inference.

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

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

Schema description coverage is 100%, so both parameters (amount_rp, package_id) are already fully documented, including the override relationship. The description restates the package tiers and built-in minimum but adds no syntax or format detail beyond the schema, which is the baseline-3 case.

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 ('Create a prepaid credit top-up invoice payable via Indonesian QRIS') and immediately scopes it to banks/e-wallets and the pricing model. An agent can distinguish this from the many account/app/push siblings without opening any schema.

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

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

Explicitly gives the trigger ('when the user wants to add credit balance') and a negative case with a named alternative ('do not use it to check whether an existing invoice has been paid (use check_billing_and_qris_status instead)'). This is exactly the when/when-not/alternative structure that removes ambiguity.

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, but the description adds non-obvious context: the required PUSHNOTIF_API_KEY and the fact that the call costs 0 credits. It also discloses the exact return shape, which 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?

Three sentences, front-loaded with purpose then routing then operational facts, with zero filler. The inline JSON return spec earns its length because no output schema exists.

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

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

With no output schema, the description correctly supplies the return structure (summary/campaigns/scheduled_queue) plus auth and cost constraints. An agent has everything needed to call and interpret this tool.

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

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

Schema description coverage is 100% and both parameters (limit range/default, app_id format) are fully documented in the schema. The description adds no parameter-level syntax or semantics beyond that, so the baseline 3 applies.

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

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

Specific verb+resource with the exact metrics enumerated (sent count, click count, CTR, credits spent, scheduled queue). It also names the sibling alternatives it must not be confused with, so an agent can discriminate without opening schemas.

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

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

Explicit when-to-use ('audit campaign performance or find scheduled campaign IDs') and when-not-to-use with two named alternatives (check_billing_and_qris_status, list_subscribers). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds auth requirements (PUSHNOTIF_API_KEY), cost (0 credit), and the exact return payload shape. These are behavioral facts the annotations cannot express.

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

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

Front-loads the purpose, then the when/when-not, then prerequisite and side-effect facts, then return fields. Sentences are dense but each carries distinct decision-relevant 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, the description compensates by enumerating the returned JSON fields. Combined with auth, cost, and prerequisite disclosure, an agent has everything needed to call and interpret this tool.

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

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

Schema description coverage is 100% and already documents both app_id (app_xxxx format, from list_apps) and the framework options. The description restates the same framework list and app_id prerequisite without adding syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (generate) and resource (SDK installation code / service worker setup instructions) scoped to an app_id and framework. It also explicitly distinguishes itself from send_push_notification, so an agent can route between them without inspecting schemas.

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

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

Gives an explicit trigger ('when a developer asks how to install PushNotif on HTML, Laravel, Next.js/React, WordPress, or Flutter/mobile'), an explicit exclusion ('do not use it to send notifications – use send_push_notification instead'), and a prerequisite ('call list_apps first to get app_id').

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, but the description adds the PUSHNOTIF_API_KEY requirement, zero credit cost, and the exact JSON return shape. For a read-only listing tool, this additional auth, cost, and output context is substantial.

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

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

The definition front-loads the core purpose, then usage prerequisites, then operational details and the return shape. Every sentence adds actionable information, and the density is appropriate for a tool an agent must call before several others.

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 parameters and no output schema, the description carries the full burden of explaining the return structure, and it does so explicitly. Combined with prerequisite guidance and sibling differentiation, an agent has everything needed 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?

There are no parameters, so the schema is empty and schema description coverage is effectively 100%. The description cannot add parameter semantics beyond confirming the tool takes no input; baseline 4 applies for zero-parameter tools.

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 (registered websites and mobile apps) with scope (authenticated PushNotif workspace) and return contents (active subscriber counts and credit balance). It distinguishes itself from list_subscribers by explicitly directing device-token inspection there.

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

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

Explicitly instructs to use it first as a prerequisite before send_push_notification, schedule_push_notification, get_integration_guide, and configure_inapp_banner to obtain a valid app_id. It also names list_subscribers as the alternative for inspecting individual device tokens, covering when-not-to-use.

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 genuinely new behavioral facts beyond the annotations: the required PUSHNOTIF_API_KEY credential and the 0 credit cost. It stops short of discussing pagination or rate limits, which keeps it from 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?

Front-loaded with purpose, then usage, then constraints, then return shape. Dense and largely waste-free, though the embedded return-shape enumeration is long enough to make the single paragraph slightly heavy.

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, but the description supplies the return JSON shape (total_active, platform_breakdown, subscribers array with fields), plus credential and cost context. An agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so both parameters (limit with range and default, app_id format and omission semantics) are fully documented in the schema. The description only references app_id filtering at a high level, adding little beyond the structured fields; baseline 3 applies.

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

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

States a specific verb+resource (retrieve active subscriber device records and platform breakdown counts) and explicitly scopes to a workspace or app_id. It also names the sibling it is not (get_campaign_analytics), so an agent can distinguish it without opening schemas.

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

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

Gives explicit when-to-use cases (inspect audience size, platform distribution, subscriber tags) and an explicit when-not with the correct alternative tool named. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false. The description goes further by disclosing that it is rate-limited against brute-force attempts and carries no credit cost, which is real operational context an agent cannot get from structured fields. It stops short of describing failure/error behavior, which keeps it out of 5 territory.

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

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

Three sentences, front-loaded with purpose before routing guidance and behavioral notes. The inline return-shape JSON is slightly dense but earns its place since no output schema exists.

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-param auth tool with no output schema, the description covers purpose, correct/incorrect usage, cost, rate limiting, and the exact return payload shape. An agent has everything needed to call and interpret 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 100% for both parameters, so the schema already documents email and password fully. The description adds no syntax, format, or constraint detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Authenticate an existing PushNotif account') plus what it yields (API key, apps list). It also explicitly distinguishes itself from register_new_account and request_registration_otp, so an agent can route correctly without opening sibling schemas.

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

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

Gives an explicit when-to-use ('an existing user wants to connect their account in chat without opening the web dashboard') and an explicit when-not-to-use with named alternatives for new signups. Nothing is left to inference.

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

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

Annotations only give the generic safety flags (readOnly=false, idempotent=false, destructive=false), while the description adds high-value context: it is a public endpoint needing no prior API key, it irreversibly creates a tenant record, it auto-generates ECDSA P-256 VAPID keys, and it grants 1,000 free lifetime credits. That is well beyond what the annotations 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?

The main action is front-loaded in the first clause and the routing exclusions follow, so the important information comes first. It is a dense single paragraph and the trailing inline JSON shape is verbose, but every sentence carries actionable information.

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

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

There is no output schema, and the description compensates by spelling out the return shape ({ ok, tenant, app } with nested fields). Combined with the stated prerequisites, irreversibility, and key generation, an agent has everything needed to call this 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 100%, so every parameter (name, email, password, otp_code, site_url, site_name) is already documented in the schema, which sets the baseline at 3. The description reinforces the 6-digit OTP and its link to request_registration_otp but adds no syntax, format, or defaulting 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?

The description names a precise multi-step outcome: verify OTP, create a tenant account, register the first website app, and issue a live API key. It explicitly distinguishes itself from create_app and request_registration_otp, so an agent can route correctly without opening any schema.

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

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

It states the exact trigger condition ('immediately after request_registration_otp once the user provides otp_code') and an explicit exclusion with the correct alternative ('do not use it to add extra websites to an existing account (use create_app instead)'). Both when-to-use and when-not-to-use are covered.

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?

Goes well beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true) by disclosing auth requirements (public endpoint, no API key), rate limits (5 per 10 minutes per IP), duplicate-email checking, OTP lifetime (10 minutes), and the response shape. These are exactly the operational facts the annotations cannot express.

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?

Purpose is front-loaded in the first clause, followed by usage routing, then operational constraints, then the return shape. Every sentence carries distinct information; none repeats the name or schema verbatim.

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 supplies the return object ({ ok, status, email, message }), and it covers preconditions, rate limits, and next-step tooling. An agent has everything needed to call this correctly on the first attempt.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaning about the email parameter: it is checked for duplicates and is the address the OTP is sent to. The optional name parameter is not elaborated beyond the schema, keeping this just short of the top score.

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+effect: sending a 6-digit email verification OTP to start a PushNotif registration. It explicitly names the sibling it must not be confused with (login_existing_account), so an agent can disambiguate it without opening either schema.

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

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

Gives explicit when ('use this tool first when a user wants to create a new account from chat'), when-not ('do not use it for existing accounts'), the named alternative, and the downstream sequencing ('before calling register_new_account'). Nothing is left to inference.

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

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

Annotations cover the safety profile (readOnly=false, destructive=false, idempotent=false), and the description adds context the annotations do not carry: PUSHNOTIF_API_KEY requirement, credit billing of 1 per delivered device charged only at dispatch execution, and that cancellation deletes a queued job before execution. The cancel-is-delete wording is consistent with a not-yet-delivered job rather than user data destruction, so it does not contradict destructiveHint=false.

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?

Purpose and the primary routing rule are front-loaded, and nearly every sentence carries load (prereqs, auth, billing, return shape). It is a dense single block with no formatting, which makes the two operating modes harder to scan than they need to be.

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 compensates by disclosing the return shape ({ ok, action, scheduled_campaign: {...} }), and it covers prerequisites, auth, billing timing, and both operating modes. Complete enough for an agent to invoke correctly on the first try.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the crucial mode-switching semantics: passing cancel_campaign_id cancels, whereas passing app_id + title + body + scheduled_for creates. It also flags the ID format expectations, though individual field-level constraints largely duplicate 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 (schedule/cancel) plus resource (future push notification campaign) and explicitly distinguishes itself from the sibling send_push_notification for immediate sending. An agent can tell the two apart without opening either schema.

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

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

Names the when ('delayed or recurring broadcasts: daily, weekly, cron'), the when-not ('immediate sending'), the alternative to use instead, and the precondition calls (list_apps for app_id, get_campaign_analytics for cancel_campaign_id). Routing is fully determined.

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-read-only, non-idempotent, open-world behavior, but the description adds substantial context beyond them: required PUSHNOTIF_API_KEY, per-device credit cost (Rp 0.20) with 0 credits for auto-pruned 404/410 dead tokens, and irreversibility once dispatched. This is exactly the billing/side-effect detail an agent needs before firing a broadcast.

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?

Dense but front-loaded: the core action and channel list lead, followed by usage exclusions, prerequisites, cost, and return shape. Every sentence carries actionable information and none is padding.

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, but the description enumerates the return JSON fields (campaign_id, totals, pruned tokens, credits). Combined with prerequisites, cost, and irreversibility, an agent has everything needed to call this destructive-ish broadcast 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 100%, so the schema already documents all five parameters including segment, url defaults, and length bounds. The description's restatement of segment='all' vs a tag name adds only marginal value beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb (broadcast), resource (immediate push notification), and the three delivery channels (Web Push/VAPID, FCM, APNs) scoped to a specific app_id. It explicitly distinguishes itself from schedule_push_notification and configure_inapp_banner, so an agent can route correctly without opening other schemas.

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

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

Gives explicit when-to-use ('instant real-time delivery'), two when-not-to-use cases with the exact alternative tool named for each, and a prerequisite ('call list_apps first to obtain app_id'). Nothing is left to inference.

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

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

Beyond the annotations (which already declare idempotentHint and destructiveHint=false), the description adds critical context: it requires PUSHNOTIF_API_KEY, it is idempotent, it has zero configuration cost but incurs 1 credit per new subscriber when welcome_enabled=true, and it returns a specific JSON shape. This is rich behavioral detail that goes well beyond what annotations provide.

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

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

The description is front-loaded with purpose, followed by usage and exclusions, prerequisite, and behavioral/return details. Every sentence earns its place and there is no redundant or filler text.

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

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

Given the 5-parameter schema with no output schema, the description covers all necessary context: purpose, alternatives, prerequisite, authentication needs, cost model, idempotency, and the exact return JSON shape. An agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already explains each parameter thoroughly. The description adds meaning for welcome_enabled by noting the cost per new subscriber when true, which is not in the schema. For the remaining parameters it largely summarizes rather than adding new semantic detail, so it improves on the baseline but does not fully elaborate every parameter.

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

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

The description states a specific verb (Configure) and resource (application's notification icon URL and welcome push notification), and explicitly distinguishes this tool from siblings by naming update_profile and configure_inapp_banner as alternatives for other tasks. An agent can identify the tool's scope without opening the schema.

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

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

It provides explicit when-to-use ('customize app-level branding and onboarding welcome alerts'), when-not-to-use ('do not use it to change account-level workspace names ... or in-page popups'), names the alternative tools, and states a prerequisite ('call list_apps first to obtain app_id'). Nothing is left to inference.

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

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

Annotations declare the mutation profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), and the description adds context annotations cannot carry: the required PUSHNOTIF_API_KEY, zero credit cost, and the overwrite semantics for the workspace name and password hash. It also discloses the return shape, which matters because there is no output schema.

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

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

Front-loaded with purpose, then exclusions, then requirements, then return shape – a logical order with no filler. Slightly dense at four sentences, but every clause carries operational 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, the description supplies the response shape ({ ok, tenant, password_updated }); with 100% schema coverage on params, it does not need to repeat field syntax. Auth, cost, overwrite behavior, and the sibling exclusion are all covered, so an agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100% and both parameters are fully documented in the schema, so the baseline of 3 applies. The description adds a small amount of semantic detail (that name is overwritten and that the password hash changes only if new_password is supplied), but no format or validation info 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?

Names a specific verb+resource ('Update the authenticated tenant's workspace display name or account password') and scopes it to account-level profile fields. It explicitly names the sibling update_app_branding as the tool for logo/push-message branding, so an agent can separate the two without opening either schema.

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

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

Gives an explicit when-to-use ('only for account-level profile or password changes') and an explicit when-not-to-use with the alternative named ('do not use it to change a website's notification logo or welcome push message (use update_app_branding instead)'). Nothing about tool selection is left to inference.

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