Carryo Website Publisher

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, establishing that this is a safe read operation. The description adds valuable behavioral context beyond the annotations: the account scope, the explicit exclusion of billing/purchase data, and the nuance that each websiteOverrides entry applies only to its matching linkId.

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 composed of three purposeful sentences with no filler. It front-loads the core purpose and then adds scope and response nuance. The first sentence is a somewhat long enumeration of checks, but each listed item meaningfully contributes to specifying what the tool reports.

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

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

For a zero-parameter, read-only capability check with an output schema, the description is complete enough for an agent to invoke it correctly. It states what the tool reports, explicitly excludes billing/purchase information, and clarifies the websiteOverrides behavior. The agent can predict the response semantics without additional assumptions.

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

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

The input schema has no parameters, so there is nothing for the description to clarify about inputs. The description appropriately focuses on the meaning of the response instead, explaining what capabilities are included and how websiteOverrides behaves. This fits the baseline 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?

The description uses a specific verb ('Checks') with a clear resource ('publishing availability for the connected Carryo account') and enumerates the concrete dimensions it covers, such as remaining capacity, reset timing, and allowances. This clearly distinguishes it from the website.* siblings, which operate on individual websites rather than the account level.

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

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

The description gives clear context for when the tool would be relevant—checking account-level publishing capabilities—and notes that it excludes billing or purchase information. However, it does not explicitly state when to prefer this tool over sibling tools like website.publish or website.read, nor does it name alternatives; the usage context must be inferred.

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

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

Annotations already declare readOnlyHint and non-destructive behavior, so the description adds value by noting that only teams accessible to the connected account are returned and that role/action information is included. This gives agents practical expectations about scope without contradicting 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?

The description is short and front-loaded with the core behavior. The second sentence is somewhat redundant with the first, but the third sentence usefully redirects admin operations to the web app without adding significant length.

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 parameterless read-only tool with an output schema and safety annotations, the description covers scope, access constraints, and out-of-band operations. Nothing essential is missing for an agent to select and call the tool 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 has zero parameters, so there is nothing for the description to clarify beyond the schema. Per baseline for parameterless tools, this is sufficient.

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

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

The description clearly states the tool lists Carryo teams accessible to the connected account and enumerates the fields included (names, workspaceId, roles, actions). This distinguishes it from the website-focused sibling tools by identifying the resource type (teams) and the operation (list).

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

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

The description gives clear context for when the tool is useful: finding a team the user has chosen. It also explicitly excludes team creation, invitations, membership, and billing by redirecting those to the Carryo web app, providing a when-not boundary even though it doesn't name alternative sibling tools.

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

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

The description goes well beyond the annotations by disclosing destructive semantics ('Replaces the complete HTML'), preserving linkId/URL, returning management links, checking access and edit limits, using expectedVersionNumber for conflict detection, and explaining failure states (requires_adaptation/requires_entitlement with publicationPerformed false). It also details asset hosting behavior and unsupported formats. No contradiction with readOnlyHint=false or destructiveHint=true.

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 dense but appropriately sized for a tool with 10 parameters and complex asset/form behavior. The core action is front-loaded, but later sections cover asset rules, form rules, and failure conditions in a somewhat list-like way that could be structured more cleanly. Still, every sentence contributes information.

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

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

Given the tool's complexity, the description covers the full lifecycle: what it does, what it preserves, what it returns, access and versioning checks, image asset constraints, form semantics, and failure modes where the update is not applied. The presence of an output schema reduces the need to describe return shapes, and nothing important appears 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?

Although schema description coverage is 100%, the description adds substantial operational meaning beyond the schema: the mutual exclusivity and import behavior of fileId/sourceUrl, 'Base64 bytes and data URLs are unsupported,' the semantics of removeAssetPaths, expectedVersionNumber's conflict-detection role, and detailed behavior of forms. This richly compensates for the many parameters and nested structures.

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 leads with a specific verb and resource: 'Replaces the complete HTML of an existing Carryo website while preserving its linkId and URL.' This clearly distinguishes it from siblings such as website.edit_images (image-only edits) and website.publish (publishing/scheduling), making the tool's scope unmistakable.

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

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

The description gives clear context: 'Suitable for updating, fixing, or republishing a known page.' It does not explicitly name alternatives or exclusions, but the 'complete HTML' scope strongly implies when this tool is appropriate versus image-only or draft-only operations, which is enough for an agent to make a routing decision.

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 readOnlyHint=false, so the mutation risk is known. The description adds valuable behavioral context: reusing a path doesn't consume another image slot, new paths are subject to allowance, Carryo imports and hosts its own copy, and base64/data URLs are unsupported. This goes beyond the annotations without contradicting them.

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 dense but well-structured, front-loading the core action and then explaining key constraints. Every sentence adds information. It's slightly long but justified given the complexity of the tool's behavior (allowance, path reuse, source types).

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

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

The description covers the essential behavioral rules: path reuse, allowance, source requirements, and unsupported formats. The output schema exists, so return values don't need explanation. Minor gaps: it doesn't explicitly state what happens when removeAssetPaths conflicts with assets, or whether the operation is atomic, but these are edge cases.

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 parameters thoroughly. The description adds meaningful context beyond the schema: the distinction between reusing a path (no extra slot) vs new paths (allowance applies), and the import/hosting behavior. This is above the baseline 3 because it clarifies the semantics of the assets array and the relationship between fileId and sourceUrl.

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 ('Adds, replaces, or removes') and resource ('hosted images on an existing Carryo website'), and explicitly distinguishes itself from website.edit by noting it does not replace HTML. This clearly differentiates it from sibling tools like website.edit and website.save_draft.

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 explains when to use this tool (to manage images without touching HTML) and provides clear context about path reuse, image allowance, and source requirements. It doesn't explicitly name alternatives or say 'use X instead', but the context is strong enough for an agent to select it appropriately among siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds useful behavioral detail about listing live sites and drafts, default personal scope, and returning 'effective edit and inactivity policies.' It does not contradict the annotations and adds context beyond the structured metadata.

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 deliver the resource, default scope, and a practical use case without filler. The wording is packed but still readable; the only minor cost is the dense list of returned fields in the first sentence.

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 an output schema present, the return values are already covered. The description provides the essential selection context (personal vs team), the connection to the account, and the read-only nature consistent with annotations. Nothing necessary for 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 description coverage is 100%, and the schema already documents workspaceId as optional, exact, and team-selecting. The description repeats the default behavior rather than adding meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Lists') and resource ('connected account's live Carryo websites and private drafts'), and enumerates the returned fields. This distinguishes it clearly from siblings like website.read or website.list_versions, which target single websites or versions rather than the website collection.

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: 'Suitable for finding a website by name' and explains the default behavior for Personal websites versus selecting a team via workspaceId. It does not explicitly name alternative tools or exclusion conditions, so it stops just 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?

The description explicitly states 'without changing the website,' reinforcing the readOnlyHint and destructiveHint annotations. It also adds context that the tool 'Returns version metadata,' which clarifies the nature of the operation beyond the annotations 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?

The description is two sentences with no filler. It front-loads the core action and purpose, then adds a concise behavioral guarantee. 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 simple read-only list operation with one parameter, an output schema, and annotations covering safety, the description is complete. It gives purpose, scope, and non-destructive intent without missing critical information an agent would need.

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 only parameter, linkId, is already fully documented in the schema with 'Carryo page link identifier to inspect.' Schema description coverage is 100%, so the description does not need to add parameter meaning. It remains at the baseline because no extra parameter context is provided.

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

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

The description clearly states the action ('Lists previous versions of a Carryo website') and the resource scope ('previous versions'). It also specifies what is included ('version details and changes') and distinguishes itself from sibling tools like website.list and website.read_version.

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 provides clear context for when to use this tool: 'for reviewing edit history or planning a restoration.' It does not explicitly name alternatives or exclusion conditions, but the intended use cases are evident, so it earns a 4 rather than 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 indicate it's a write operation (readOnlyHint=false) with side effects (openWorldHint=true). The description adds critical context: it consumes the account creation allowance, imports and hosts its own copy of images, returns live and management links, and can return validation errors (requires_adaptation/requires_entitlement) with publicationPerformed false. It also highlights limitations (no backend hosting) that go beyond annotations. Loses a point because it could mention the side effect of overwriting any existing site with the same slug? But not required as this is creation.

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 dense but each sentence earns its place. It front-loads the core purpose and use cases, then covers key constraints (account allowance, image handling, validation failures) without fluff. It is longer than typical but every part adds critical information that is not in the schema.

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

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

With an output schema present)Skip the return details are covered. The description covers all necessary aspects for correct invocation: prerequisites (account allowance), parameter semantics (assets), error handling (validation errors), and scope limitations (only HTML pages, no backend). It leaves nothing significant to guess.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by explaining how assets must be set up (relative HTML paths, exactly one source, base64 unsupported), how forms work (window.CarryoForms.submit), and the behavior of imageFiles (temporary download URLs). It clarifies customSlug generation and the role of expiresAt. Already high, so 4 is warranted for the extra depth.

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

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

The description clearly states the tool publishes supplied HTML as a new public Carryo website, listing specific use cases (presentation, proposal, report, etc.) and contrasting with siblings like website.edit (for editing) and website.save_draft (for drafts). It distinguishes itself by the 'new' and 'public' aspects.

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 explicitly states the default destination is Personal and that workspaceId is used for a user-chosen team, and mentions checking account creation allowance. It does not explicitly name alternatives for when not to use, but the sibling list (website.edit, website.save_draft) context implies this is for creation. It also notes what is unsupported (general file storage, backend hosting) to prevent misuse.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is safe. The description adds useful behavioral specifics: it returns HTML, version number, hosted-image metadata, and image limits, and explains that replacing an existing asset path does not consume a new image slot. This goes 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?

Three sentences, all substantive. Front-loaded with the primary purpose and return contents, then the image-slot caveat. No filler or repetition of schema property names.

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

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

For a single-parameter read tool with readOnly/destructive annotations and an output schema, the description covers what is read, what is not returned, and an edge case about image slots. Nothing the agent needs to decide whether to call it or interpret its purpose 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% and the single parameter (linkId) is already self-describing in the schema. The description doesn't add new detail about the parameter's format or constraints, but it does state the tool's scope (existing website or draft), which is lightly relevant. Baseline 3 applies because schema fully covers this simple 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 ('Reads') and a precise resource: the current HTML, version number, image metadata, and image limits of a Carryo website or private draft. It clearly distinguishes itself from siblings like website.edit and website.read_version by focusing on reading current content rather than modifying or inspecting a specific historical version.

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

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

The description gives clear use cases: inspecting a page or preparing edits that preserve existing images. It also clarifies that it returns metadata, not image files, which helps an agent choose this over tools that may return binaries. It does not explicitly name alternative tools or state when not to use it, but the context is adequate for selection.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, but the description adds valuable context: responses contain untrusted visitor data, retention behavior is tied to website access including a billing grace period, and it explicitly states the tool does not send messages or modify data. These details go beyond the annotations and help the agent understand data handling and safety.

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

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

The description is a single paragraph of four sentences, front-loaded with the core purpose and mode behavior. It avoids redundant details and each sentence contributes useful information, though it could be slightly more structured with bullet points for readability, but overall it is 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?

Given the tool's complexity (8 parameters, pagination, modes) and the presence of an output schema, the description covers the essential aspects: modes, access, data trust, retention, and read-only nature. Pagination parameters are documented in the schema, and return values are covered by the output schema. It lacks explicit explanation of 'formKey' and pagination cursor usage, but those are inferable from the schema.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'mode' parameter (summary vs. responses) and the 'fields' parameter (optional selection), but does not explain 'after', 'before', 'cursor', 'limit', 'formKey', or 'linkId'. With 8 parameters, only a couple are clarified, so the agent must infer the rest from schema constraints alone, leaving gaps.

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

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

The description clearly states the tool reads response counts or paginated visitor submissions for a Carryo website, specifying the verb 'reads' and the resource. It explicitly mentions the two modes (summary and responses) and notes that it does not send messages or modify data, distinguishing it from sibling tools like website.publish and website.edit.

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 explains the default mode (summary) and the alternative mode (responses) with optional field selection, giving the agent guidance on how to get different kinds of data. It also mentions access requirements (website-owner or Team access) but does not explicitly state when to prefer this tool over alternatives, though no direct sibling tool handles form responses, so the use case is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond annotations: it explicitly states that reading does not restore the version or change the current website, which is a key behavioral trait for an agent to know. It also clarifies the scope (HTML and metadata).

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 with zero waste. The core action and resource are front-loaded, the required parameters are stated, and the critical non-destructive behavior is called out. 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?

The tool has an output schema, so return values don't need to be described. The description covers what it reads, the required parameters, and the non-destructive behavior. It could mention that this is for a 'previous' version vs. current, which it does. It doesn't explicitly say when NOT to use it (e.g., for current site use website.read), but the context is sufficient for a read-only tool with full schema coverage.

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 both parameters (linkId and versionNumber) with descriptions. The tool description adds the requirement that both are needed ('Requires linkId and versionNumber') and clarifies that versionNumber refers to a 'specific previous' version, but this is marginal value over the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Reads'), a specific resource ('HTML and metadata of a specific previous Carryo website version'), and its purpose ('viewing, comparison, or restoration planning'). It also distinguishes itself from sibling tools like website.read and website.list_versions by focusing on reading a specific previous version rather than the current site or listing versions.

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

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

The description clearly states when to use this tool: when you need to read a specific previous version, and it explicitly notes that reading does not restore or change the current website. It doesn't explicitly name alternatives like website.read or website.list_versions, but the context of 'previous version' vs. current site is clear enough to guide selection.

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

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

The description fully discloses behavioral traits beyond annotations: no public page until published, management link returned, consumption of creation allowance, form validation errors (requires_adaptation/requires_entitlement with publicationPerformed false), image hosting behavior, and restrictions on unsupported formats. With annotations only indicating non-read-only/non-destructive, the description carries the full burden and does so thoroughly.

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 information-dense but structured efficiently: core behavior first, then asset constraints, then form behavior, then validation notes. Some redundancy exists between the top-level description and schema field descriptions (e.g., base64 unsupported appears twice), and the form-related sentences could be tighter. However, the front-loading is good and every sentence contributes meaningful 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?

Given the complexity (8 params, nested assets/forms, sibling publish/edit tools, no output schema details), the description covers all critical aspects: what the tool does, when to use it, what to know about assets and forms, what errors to expect, and what the response contains (management link, publicationPerformed). The presence of an output schema further reduces the need to explain return values, and the description already addresses key lifecycle behavior.

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 description adds meaning beyond the schema: it explains the mutual exclusivity of fileId and sourceUrl, the relationship between assets and imageFiles, the behavior of forms and static collection forms, the meaning of workspaceId vs personal default, and the lifecycle of drafts (no public page until published). The description enriches every parameter's semantics, not just repeating names.

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 first sentence clearly states the tool's action ('Saves supplied HTML as a new private Carryo website draft for review before publication'), identifies the resource (private website draft), and differentiates it from siblings by emphasizing 'private' and 'draft' before publication. This distinguishes it from website.publish, website.edit, and website.read.

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 explicitly states when to use this tool vs alternatives: it saves a draft for review before publication, notes that published websites use website.publish, and explains that editing existing websites would use website.edit. It also provides clear conditions for asset handling and form definitions, and mentions the alternative of workspaceId for team selection versus personal default. The description covers when to use it and what to avoid (e.g., base64 image bytes, data URLs).

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=truecars, and the description adds meaningful specifics: the effect is immediate, access is lost through the shared link, recovery availability is conditional and surfaced in Carryo, and the action does not cancel a subscription. This goes well beyond the structured 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?

Three short sentences, with the primary effect and scope front-loaded. Every sentence adds useful information: immediate effect, reversibility caveat, and a non-goal. No redundancy.

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

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

For a single-parameter destructive tool with annotations and an output schema present, the description covers the main action, the immediate consequence, recovery uncertainty, and a common misunderstanding. It does not describe how to obtain linkId, but the schema field description mitigates that 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 already complete (100%): the only parameter, linkId, has a clear description. The tool description adds little new parameter meaning beyond implying the linkId identifies the shared link. Baseline 3 is appropriate because the schema carries the parameter 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?

States a specific verb ('Unpublishes'), a precise subject ('existing Carryo website'), and a concrete effect ('viewers immediately lose access through its shared link'). This clearly distinguishes it from sibling tools like website.publish, website.edit, or website.read.

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 clear context for when to use it: to take a website offline immediately. It also adds an exclusion ('does not cancel a subscription'), which prevents misuse. It does not explicitly name a sibling alternative, but the tool's purpose is distinct enough that no alternative is needed.

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