CookiePilot – cookie banner & Consent Mode v2

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety and idempotency are covered structurally. The description adds genuine context by restating the idempotent return behavior and disclosing the plan constraint ("The free plan includes one website"), but never says what happens when the limit is exceeded or the token is stale, nor what object is returned.

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

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

Three sentences, front-loaded with the action and precondition, then defaults, then idempotency, then the plan limit. Every sentence carries a distinct fact, though the hostname-default sentence partially duplicates the schema.

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

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

For a two-parameter mutation with annotations and no output schema, the description covers precondition, defaulting, idempotent behavior, and the plan cap. The remaining gap is failure behavior and return value, which matters more here because no output schema exists.

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

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

Schema coverage is 100% and both parameters are documented with defaults and length bounds, so the schema does the heavy lifting. The description only echoes the schema's hostname default and the setup_token source; it adds no syntax, format, or edge-case meaning beyond it.

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 ("Adds the website to the confirmed account") and immediately scopes the precondition (setup_token must be ready). It also positions itself against create_account by explaining the hostname defaults to the website given there, so an agent can tell which sibling precedes 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 parenthetical "setup_token must be ready" gives an explicit precondition, and "An already added website is returned as is" tells the agent it is safe to call on a repeat. No alternatives or explicit when-not guidance are given (e.g., which sibling to use to change the website later), so it stops short of a 5.

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

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

Annotations already declare readOnly, idempotent and openWorld, so safety is covered. The description adds real behavioral context beyond that: no JavaScript execution and public addresses only, which tells the agent that SPA content and internal hosts won't be reflected in results. It does not mention rate limits or failure modes, but the key operational constraint is disclosed.

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

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

A single front-loaded sentence with the verb and the access constraint early, followed by the returned data. It is long, but every clause names a distinct output field, so the length is justified 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?

No output schema exists, so the description must describe return values, and it does so comprehensively, including the WCAG-check element agents would otherwise not expect. Combined with the no-JS/public-only caveat, an agent knows what it will get and what it won't. Failure behavior and a suggested next step are the only omissions.

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

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

With one parameter at 100% schema coverage, the schema already carries the URL format and example. The description adds meaning the schema lacks: only public addresses are accepted, and the fetch is a plain no-JS HTTP GET, which narrows what a valid URL can be. That is genuine added semantic value over 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 (fetches/analyzes) and resource (public homepage) and enumerates the concrete outputs: brand colours, fonts, platform detection, GTM containers, consent tools, trackers, WCAG-checked banner colours, install method. This is clearly distinguishable from siblings like get_install_snippet or configure_banner.

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 implied rather than stated: the returned 'recommended install method' and the sibling set (configure_banner, get_install_snippet) suggest this is the discovery step preceding configuration, but the description never says when to prefer this tool or what to do with the result. No explicit exclusions or prerequisites are given.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, openWorldHint=false), and the description adds genuinely new context: the setup_token backing the 'ready' state is only valid for 24 hours. That expiry window is a real behavioral constraint an agent needs. It stops short of describing polling cadence or what happens after expiry beyond the 'expired' label.

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, front-loaded with the returned values and each one glossed inline. No wasted text. It reads as a return-value spec rather than a purpose statement, which slightly hurts orientation but is efficient overall.

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

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

With one required parameter, no output schema, and rich annotations, the description covers the main gap — the meaning of each return state — which is exactly what an output-less tool needs. The remaining omission is what the agent should do next on each state (retry, wait, restart signup).

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

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

Schema coverage is 100% and the single parameter is documented as coming from create_account, so the baseline is 3. The description adds meaning beyond the schema by attaching a 24-hour lifetime to the setup_token, which tells the agent the token is time-limited rather than static.

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 enumerates the three return states (pending_email, ready, expired) which makes the tool's job — reporting account-confirmation state — unambiguous, and the title supplies the verb 'check'. It doesn't explicitly contrast itself with create_account or verify_installation, but the resource (account confirmation status) is distinct enough to separate it from siblings.

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

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

Usage is only implied: the 'pending_email ... has not finished the confirmation page yet' phrasing hints at polling after create_account before running onboarding tools. There is no explicit statement of when to call this versus create_account or verify_installation, nor whether repeated polling is expected.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=true, so the safety profile is covered. The description usefully adds two things beyond that: that the operation both saves and publishes (a live side effect), and that it returns a preview link to the CookiePilot panel. It does not say whether publishing is immediately live or whether unset fields are preserved.

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, zero preamble, with the field enumeration and the return value both front-loaded. The long run-on list of fields and the parenthetical about suggested colours make it slightly denser than needed but nothing is redundant.

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 seven-parameter mutation tool with a nested colours object and no output schema, the description does cover the return value (preview link) and the effect of the call. It omits the workflow position relative to create_account, analyze_site and verify_installation, which is the main thing an agent still has to infer.

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

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

The description maps to five of the seven parameters (colours, position, layout, font, privacy policy URL), which is meaningful against 71% schema coverage. The note that colours can come from a site analysis adds semantic value the schema cannot express, though setup_token and hostname receive no treatment in the 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?

The description pairs a specific verb ('Saves and publishes') with a concrete resource ('the banner look') and enumerates the mutable facets: colours, position, layout, font, privacy policy URL. It is clearly distinguishable from siblings like create_account, analyze_site or get_install_snippet, though it never names an alternative 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?

Usage is only implied by the phrase 'on the confirmed account' and by the mention of 'suggested banner colours from a site analysis', which hints at a prior analyze_site step. It never states when to call this rather than get_install_snippet or verify_installation, nor that it should follow create_account (the setup_token dependency lives only in the schema).

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

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

The description adds substantial context beyond the annotations: no account exists until the e-mail owner clicks the confirmation link, sets a password, and accepts terms. It also explains the setup_token and confirmation_code return values and notes that existing account holders receive a login link instead, which is important behavioral disclosure for a non-idempotent, open-world account-creation tool.

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

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

The description is front-loaded with the core action and then covers the confirmation flow and return values without repetition. The length is justified by the important caveats around e-mail confirmation and existing accounts.

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

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

For an account-creation tool with no output schema and non-idempotent, open-world behavior, the description covers the critical process, side effects, return values, and the existing-account edge case. An agent has enough information to invoke it correctly and set expectations.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description reinforces that the e-mail is the user's own and that the organization is the user's company, but it does not add syntax or meaning beyond the schema, particularly for locale and website.

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: it starts a free CookiePilot sign-up for the user's own e-mail and company. It is clear what the tool does, but it does not explicitly name sibling tools or directly differentiate itself from check_account_status or other onboarding tools.

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

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

It gives clear usage context by requiring the user's explicit request and specifying that the e-mail must be the user's own. It does not state when not to use it or name an alternative tool, such as check_account_status, before creating an account.

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/closed-world, so the bar is lower. The description still adds real behavioral context beyond them: the same call returns different content (real domain key vs. YOUR_API_KEY placeholder plus a register link) depending on whether setup_token is supplied — a non-obvious output variation with no output schema to document it.

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

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

Two sentences, front-loaded with the primary action and the platform inventory, then the token-conditional behavior. Dense but every clause carries information; the platform list is slightly enumerative but justified since it defines scope.

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

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

A read-only, idempotent tool with one required and three optional fully documented parameters and no output schema — the description covers the sole meaningful ambiguity (conditional output based on setup_token). Nothing essential to correct invocation is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description genuinely extends semantics by explaining the concrete effect of setup_token (real key vs. placeholder + register link) and by listing what the platform enum values produce. It adds meaning the schema fields do not carry.

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 ("Step-by-step install instructions") and enumerates the exact platform outputs (HTML snippet, WordPress/WooCommerce plugin, PrestaShop, GTM, Shoper). This is clearly distinguishable from siblings like analyze_site and verify_installation 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?

Usage context is implied rather than stated: the setup_token clause signals this should be called after create_account, and the schema notes platform usually comes from analyze_site's recommendedInstallMethod. But the description itself never says when to call this versus verify_installation or analyze_site, and gives no exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered. The description adds genuine value beyond that by disclosing the return contents: cheapest eligible plan, prices and limits of all plans, and a register link, which tells the agent what a call yields.

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

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

A single sentence that front-loads the action and its inputs, with no filler. Slightly dense with multiple clauses, 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 simple read-only, single-required-parameter tool with no output schema, the description covers the inputs, the selection logic (cheapest), and the shape of the response. Nothing critical is missing, though noting the pre-checkout placement 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?

Schema description coverage is 100%, so the schema already documents locale, domains, and pageview limits/units thoroughly. The description only restates that monthly_pageviews is user-stated traffic; it adds no syntax or edge-case guidance 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 and resource ('Recommends the cheapest CookiePilot plan') with the exact inputs that drive the recommendation and what is returned. Clearly distinguishable from siblings like create_account or start_checkout, which act on a chosen plan rather than selecting one.

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 word 'Recommends' plus the pricing/register-link return hints this is a pre-purchase step before create_account or start_checkout, but the description never says when to use it or when not to. 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?

Goes meaningfully beyond annotations by disclosing the offloaded payment flow: "Payment happens only on Stripe's page; the tool takes no card details." That clarifies an openWorld, non-readonly side effect in a way the hints alone cannot. It does not mention that each invocation spawns a fresh non-idempotent checkout session or how long the link lives, which is the missing piece.

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 zero filler; the return value and plan scope are front-loaded, and the payment-safety caveat follows immediately after.

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

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

For a three-parameter, side-effecting, open-world tool with no output schema, it covers the essentials: what comes back (a Stripe link), what the token means, and that no card data is handled. It falls short only on the returned link's lifetime/reuse behavior and on the undocumented period parameter.

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%, so the description must carry weight; it does map "Pro or Business plan" onto the plan enum and ties "confirmed account" to setup_token. However, the period parameter (monthly/yearly) is never mentioned in either the description or the schema, leaving one of three parameters semantically bare.

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 ("Returns a Stripe Checkout link") scoped to the Pro/Business plans on a confirmed account. That scope cleanly separates it from siblings like recommend_plan (pre-purchase advice) and check_account_status (verification), so an agent can pick it 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?

Preconditions are stated explicitly — the account must be confirmed and the user must already have chosen a paid plan — plus the setup_token's origin (create_account) is named in the schema. There is no explicit exclusion or named alternative (e.g., what to do if the user has not yet picked a plan), so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds real value beyond that: it discloses the two-tier check (verified status first, then a fallback inspection of homepage HTML) and that the response includes a user-facing hint — behavior an agent could not infer from the schema alone.

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

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

A single sentence that front-loads the primary answer (verified or not) before the fallback condition and the hint. No filler, no restatement of the title or 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?

With no output schema, the description carries the burden of describing return states, and it does so: verified, code-present-in-HTML, and a hint. It stops short of describing failure cases (invalid hostname, unreachable site) or whether a live fetch occurs, which would round out the picture for an openWorld network operation.

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

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

Schema description coverage is 100%, so both `hostname` (with its default-to-create_account behavior) and `setup_token` are fully documented in the schema. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Reports') with a concrete resource state: whether the banner has been seen running, and if not, whether the code is present in the homepage HTML. This is functionally distinct from siblings like get_install_snippet or analyze_site, though the description never names or explicitly contrasts itself with those alternatives.

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

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

Usage is only implied: an agent can infer this is the post-installation confirmation step, but the description never says 'use this after adding the snippet' or points to alternatives when verification fails (e.g. get_install_snippet). The two outcome states hint at when it matters without stating it.

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