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

With no annotations provided, the description carries the full behavioral burden. It discloses the multi-step pipeline, the asynchronous wait for import to finish, and the cost of 4 credits. It does not mention failure modes, overwrite semantics, or reversibility, but the disclosed workflow is substantial and helpful.

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 three tight sentences with no filler: the main action is front-loaded, cost is stated up front, and parameter guidance is last. Every sentence earns its place and the structure is easy to scan.

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 multi-step, asynchronous, cost-incurring tool with no output schema, the description covers the essential context: what gets built, how the plan is chosen, the blocking wait, and the credit cost. It omits return-value details and failure handling, but these are moderately covered by the wait wording and sibling status tools.

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

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

Schema coverage is 100%, so the schema already documents both parameters fully. The description reiterates the pass-or-omit behavior of `plan` but adds no genuinely new parameter-level detail beyond the schema, keeping this at the baseline.

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

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

The description specifies a concrete action chain: assemble the plan into pages, generate copy from the brief, select stock photos, import into the site, and wait for completion. This clearly identifies the tool's resource (a plan) and its outcome, distinguishing it from planning, review, and import-demo siblings without needing to name them.

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 usage context: build either an edited plan passed explicitly or the stored plan when omitted. It communicates when the tool enters the workflow (after planning) and how to control which plan is built, but it does not explicitly state when not to use it or name alternative 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what is returned but does not mention that this is a read-only operation, any required permissions, or whether it triggers side effects. The lack of an explicit read-only or idempotency signal is a gap for an agent assessing 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, tightly written sentence with no filler. It front-loads the core content (site plan, brief, timestamps) and omits redundant detail. Excellent economy of words.

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

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

For a simple retrieval tool with one optional parameter and no output schema, the description states the return contents adequately. However, it lacks usage context (when to call, what distinguishes it from plan-generation tools) and does not hint at the structure of the returned plan, which could matter for an agent deciding how to use the output. This is a minimum-viable description but leaves gaps.

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

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

Schema description coverage is 100% for the single boolean parameter, and the description adds no additional meaning beyond that. Since the schema already documents 'include_sections', the description neither clarifies nor expands on it, matching the baseline score of 3.

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 returns a stored site plan (pages and sections), the originating brief, and build/review timestamps. It names the resource and the fields returned, which is specific. However, it does not explicitly contrast with sibling tools like sweipe_ai_plan or sweipe_ai_build, so an agent must infer the distinction.

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

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

No guidance is given on when to use this tool versus alternatives such as sweipe_ai_plan (likely for generating a new plan) or sweipe_site_from_brief. The description does not mention prerequisites, typical use cases, or any 'when not to use' conditions, leaving the agent to guess.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the informational nature of the tool by framing it as a template library and enumerating expected result fields. However, it does not explicitly state that the call is read-only, that it returns a list, or any other behavioral guarantees, leaving some of that to inference.

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 and front-loads the essential definition before giving the downstream integration hint. There is no filler or redundancy. It earns its place, though it could be marginally improved by adding an explicit action verb.

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

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

With no output schema and no annotations, the description must do most of the documentation work. It covers the semantic content of the library and how the data feeds into planning, which is helpful. But it does not specify the return shape (e.g., list of template objects) or clarify whether the planner automatically picks from all templates, leaving small but real gaps.

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

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

The tool has zero parameters, and schema coverage for parameters is vacuously 100%, so the baseline is 4. The description adds no parameter documentation for this tool, which is fine since there are none; it instead explains the meaning of the `base` parameter used by a sibling tool, which is useful context.

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 names the resource ('templates a site can be planned from') and lists the key fields (slug, name, design, required plugins), so an agent can tell what domain object this tool exposes. It also connects to sweipe_ai_plan, which helps distinguish it from planning itself. However, it lacks an explicit verb such as 'list' or 'retrieve,' so the operation is inferred rather than directly stated.

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

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

The description gives useful workflow context: a returned slug can be passed as `base` to sweipe_ai_plan, or the planner can choose. This implies when the tool is relevant, but it never explicitly states when to call this tool versus siblings or when not to use it. The usage guidance is present but implicit.

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

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

With no annotations, the description carries the full burden. It discloses that it is a round-trip network call and what it returns (licence acceptance, credit balance details). However, it does not mention potential side effects (though likely read-only), error behavior, or whether it incurs costs or rate limits. It adds some behavioral context beyond the schema, which is empty.

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, well-structured sentence that leads with the core action and immediately specifies the return value. No wasted words; it is front-loaded and efficient.

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 tool with no output schema, the description covers the essential return information (credit balance components). It does not mention error cases or whether the licence acceptance is a precondition for other calls, but for a simple ping tool it is nearly complete. A slight gap is the lack of any note on expected response format or failure modes, but it is adequate for its simplicity.

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

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

The tool has zero parameters, so the schema provides no parameter info. The baseline for 0 params is 4. The description correctly adds no parameter details since none exist, and it does not mislead. The credit balance details in the description give some context about what the response will contain, but that is not 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?

The description clearly states a specific verb ('Round trip'), the resource ('Sweipe AI service'), and the outcome (confirms licence, returns credit balance). It distinguishes itself from siblings like sweipe_ai_get_plan (plan details) and sweipe_status (general status) by specifying its exact scope.

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

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

No guidance on when to use this tool versus alternatives. It does not state that it is a lightweight health check or a prerequisite for other sweipe operations. The agent is left to infer its role from the purpose, with no explicit exclusions or preferred conditions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool costs 1 credit, that it produces a page-and-section plan, and that the plan can be reviewed and edited before building. This is meaningful behavioral context, though it does not state whether the plan is persisted, overwrites an existing plan, or requires any setup state.

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

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

The description is two sentences with no filler. It front-loads the core transformation, adds the credit cost, and closes with the workflow next step. Every clause earns its place.

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

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

The description explains the output shape (pages and ordered sections), the required input (brief), the cost, and the recommended next step. There is no output schema, so describing the plan contents is important and well handled. Minor gaps remain around error cases and what happens to previously stored plans, but the definition is complete enough for invocation.

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

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

Schema description coverage is 100%, so the input schema already documents brief, base, and language. The description adds context about what the plan contains and that base comes from the template library, but it does not materially deepen the meaning of any individual parameter 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 clearly states the action: turn a one-paragraph business brief into a site plan of pages and ordered sections from the template library. It also names the next step (sweipe_ai_build) and the credit cost. However, it does not explicitly distinguish itself from closely related siblings like sweipe_brief_generate or sweipe_site_from_brief, so full sibling differentiation is missing.

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

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

The description implies when to use it: when you have a brief and need a reviewable plan before building. It also gives explicit workflow ordering with 'before sweipe_ai_build' and notes the plan can be edited. It does not state when not to use it or name alternative plan-related tools, but the context 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?

No annotations are provided, so the description carries the full burden. It discloses the cost (5 credits, fix 2, free when nothing broken), the return payload (score, summary, changes, changed), and the review workflow. However, it does not explicitly state whether the tool is read-only or mutating (e.g., whether it modifies the plan), which is a notable gap for a tool that returns 'changes made to the plan'.

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 compact and information-dense. Every sentence adds value: what it does, what it returns, and the follow-up workflow. It is front-loaded with the action verb and specific checks, and it avoids redundancy or filler.

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

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

For a tool with one parameter and no output schema, the description explains the return values (score, summary, changes, changed) and the branching workflow. It covers the mode distinction and cost. Missing details include prerequisites (e.g., that a build must exist) and potential error conditions, but these are minor given the tool's simplicity and the clear workflow.

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

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

The schema already documents the single parameter `mode` with enum values and descriptions for each mode. The tool description references mode 'fix' but adds no new semantic information beyond the schema. With 100% schema coverage, the description's contribution here is minimal, so a 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 clearly states the tool's purpose: render every built page, inspect for issues, take screenshots, and judge against the brief. It specifies the resource (built site) and the actions, and it naturally distinguishes from siblings like sweipe_ai_build (which builds) and sweipe_status (which likely checks status).

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 explicit workflow instructions: if the returned `changed` is true, call sweipe_ai_build again and then review with mode 'fix'. It also explains the two modes and the credit costs. However, it doesn't explicitly state when to use this tool versus alternatives like sweipe_status or sweipe_list_demos, leaving some inference needed for general usage context.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It indicates a mutating toggle but does not disclose persistence, side effects on existing AI workflows, permission requirements, or the response/return behavior after the switch.

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

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

One compact sentence communicates the operation, scope, and admin location with no filler. Every phrase earns its place, and the key verb/object combination is front-loaded.

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-boolean toggle with no output schema and no annotations, the description covers the core need: what is switched, where, and for what scope. It is slightly incomplete regarding how to inspect the resulting state or whether the setting is site-wide vs. user-specific, but the core invocation is clear.

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

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

Schema coverage is 0%, so the description must compensate for the lone parameter. 'On or off' maps directly to the boolean `enabled` value, and 'AI features for this site' clarifies what the parameter controls, adding meaning beyond the bare schema.

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

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

The description states a specific action ('Switch'), a clear resource ('the AI features of the plugin'), and a precise scope ('for this site'), with the UI location (Sweipe → AI). This differentiates it from read/status/build siblings such as sweipe_status and sweipe_ai_build.

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

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

The description implies the tool is for enabling or disabling AI features on a site, but it does not explicitly state when to choose it over alternatives or mention any exclusions or prerequisites. The scope and UI location provide context, but no direct routing guidance is given.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool writes into pages and preserves a backup for 'sweipe_brief_undo', and it explains the optional partial-apply behavior. It could add backup lifespan or response details, but the key side effects and recoverability are covered.

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. The main behavior and backup side effect are front-loaded, and the optional parameter option is presented in the second 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?

For a write/apply tool, the description gives the agent enough to understand the workflow: apply stored drafts, optionally apply partial rows, and rely on the undo tool for backup. A return format is not described, and 'post_ids' semantics are left implicit, but these are not critical blockers.

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 schema describes 'items' meaningfully, and the description adds that 'items' applies an edited or partial set of rows per page rather than the whole draft. However, 'post_ids' has no schema description and the description does not explain the meaning of the 'id'/'new' row fields, leaving some semantics implicit.

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 opens with a specific action ('Write the stored drafts into the pages'), names the resource, and immediately differentiates itself from 'sweipe_brief_undo' by mentioning it creates the backup for that undo tool. This is clearly distinct from generating, picking, or undoing drafts.

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: use it to write stored drafts into pages, and use the optional 'items' parameter for edited or partial rows instead of the whole draft. It does not explicitly list when not to use it or name alternative tools, but the intended use is unambiguous.

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

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

With no annotations, the description carries the full burden, and it does so well: it discloses that the tool rewrites text, preserves layout, returns draft rows with id/widget/old/new, stores those rows, and does not mutate the live site until a separate apply step. It also discloses the cost: 1 credit per page.

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 three sentences with no filler. The first sentence front-loads the action and scope, the second covers return values and side effects, and the third provides the cost. 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?

Given that there is no output schema and no annotations, the description provides the essential return format, the storage side effect, the condition preventing live-site changes, and the follow-up apply step. Minor gaps remain: it does not describe optional language behavior or what happens if a draft is generated again for the same page, but the overall tool contract is clear.

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 schema only documents post_id; the description reinforces that post_id 0 means site identity and connects the brief parameter to the business in the brief, adding some context. However, the language parameter is not explained anywhere, and the brief parameter's expected content and format go only as far as a 10-character minimum in the schema. With schema coverage at 33%, this is partial but not complete compensation.

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: 'Rewrite every text on one page' for the business in the brief, while also noting the special post_id 0 case. It clearly differentiates this drafting step from applying later, especially by mentioning sweipe_brief_apply, so an agent can tell it apart from its 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?

The description explains that this tool only creates and stores drafts and that 'nothing changes on the site until sweipe_brief_apply', which gives a clear workflow context and names the follow-up sibling. It does not explicitly enumerate when not to use it compared with sweipe_brief_pick or sweipe_brief_undo, so it stops short of full 5-level guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It describes the output content in detail (counts, draft status, AI applied) and mentions the site identity block id 0, but it does not explicitly state that this is a read-only, non-mutating operation or disclose any other behavioral traits like authentication, performance, or error conditions. The read-only nature is implied but not stated.

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

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

The description is two concise sentences that front-load the resource (every page, post, site identity block) and then provide key details (counts, draft status, AI applied) followed by a direct usage instruction. There is no wasted wording.

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 listing tool with no output schema, the description fully covers what is returned (all pages/posts/site identity with metadata) and how to use it (ids with generate/apply/undo). It is complete for an agent to invoke correctly without additional context.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter information, which is appropriate since there are no parameters to explain.

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 returns an overview of every page, post, and site identity block with metadata (text item counts, draft status, AI copy applied). It distinguishes itself from sibling tools like sweipe_brief_generate by explicitly noting how to use its ids with them, making the purpose unambiguous.

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

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

The description directly instructs the agent to use the returned ids with sweipe_brief_generate/apply/undo, which is a clear usage context. However, it does not explicitly state when to prefer this tool over other listing tools (e.g., sweipe_status, wp_list_pages) or mention exclusions, leaving some usage guidance implicit.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses two useful behaviors: the operation is free, and it stores the brief for later copy generation. However, it does not explain return format, whether this is read-only or state-changing, or any side effects beyond storing the brief.

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 no filler. The primary action is front-loaded, the free aspect is a single word, and the storage side effect is a compact final sentence. 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?

For a simple two-parameter tool, the description covers the core action and one side effect, but it omits the meaning of the language parameter and any guidance on when to invoke it. Since there is no output schema, it also does not describe what the returned reasons look like. It is minimally adequate but leaves clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies that 'brief' is a business brief. The 'language' parameter is completely unexplained, and there is no guidance on format, allowed values, or optionality beyond the schema's required flag.

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 a specific action: ask the service which demo packages fit a business brief, including a reason for each. It goes beyond the title by naming the resource (demo packages) and the outcome (fit with reasons), which distinguishes it from generic listing tools like sweipe_list_demos.

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 does not explain when to use this tool versus alternatives such as sweipe_brief_generate, sweipe_list_demos, or sweipe_brief_apply. There is no mention of prerequisites, preferred inputs, or exclusion criteria, so an agent has to infer the intended use case.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly conveys the restore action and the empty-post_ids semantics, but it does not warn that restoring likely overwrites or discards the current applied copy, which would be valuable for this mutation-like 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?

One compact sentence delivers the core behavior and the one important edge case. There is no filler and no redundancy with the schema.

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

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

For a one-parameter undo tool with no output schema, the description covers purpose, scope, and parameter semantics well. Missing details such as whether a backup must already exist or whether the restoration is reversible are notable but not crippling given the tool's simplicity.

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 schema provides no description for post_ids, so the description's clarification that an empty value means all backed-up pages adds real meaning. It does not explain what individual IDs map to, but for a single optional parameter this is adequate.

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: 'Restore the pre-apply backup of the given pages'. It also clarifies the edge-case scope, 'all backed-up pages when post_ids is empty', and clearly distinguishes this as the inverse of sweipe_brief_apply.

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 'pre-apply backup' phrasing and the sibling sweipe_brief_apply make the intended use-after-apply undo scenario clear. It does not explicitly name exclusions or alternatives, but the context is sufficiently orienting for a dedicated undo tool.

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

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

With no annotations, the description discloses important behaviors: it waits for completion, never overwrites existing user pages, and takes one to a few minutes. It does not mention failure handling or what happens to non-user settings, but it provides substantial behavioral context beyond the bare operation.

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

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

Two sentences with no redundant words. The primary purpose is front-loaded, followed by concise behavioral details. Every sentence contributes to understanding the tool.

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

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

The description covers the key aspects: what is imported, that it blocks until done, preservation of user pages, and expected duration. It lacks explicit return value or error behavior, but given the simplicity and absence of an output schema, it is reasonably complete. A note on failure outcomes would be a minor improvement.

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 schema fully documents the single parameter (slug) with a clear reference to sweipe_list_demos, covering 100% of parameter semantics. The tool description does not add extra parameter detail, which aligns with the baseline of 3 when schema coverage is high.

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 (import), the resource (demo packages), and the specific content affected (pages, menus, images, settings, products when WooCommerce is active). It distinguishes itself from siblings like sweipe_list_demos (listing) and sweipe_import_status (checking status) by focusing on the import operation itself.

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

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

The description provides context about what the tool does and its blocking nature, and implies usage via the slug parameter sourced from sweipe_list_demos. However, it does not explicitly name alternatives or state when not to use this tool, which would be stronger guidance.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the tool covers both running and finished imports, which is useful. It does not explicitly state that the operation is read-only or describe error behavior for unknown or invalid import_ids, but 'progress' strongly implies a non-mutating status query.

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 well-formed sentence with no filler or repetition, and the core purpose is stated immediately. Every word contributes meaning, making it an example of efficient, front-loaded writing.

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

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

For a one-parameter status tool with no output schema, the description gives enough to understand the input and general purpose. It is slightly thin on return semantics and potential failure modes, but the simplicity of the tool limits how much context is required.

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 0% description coverage, so the description must compensate. It does: 'by its import_id' explains the purpose and role of the only parameter, which is enough for a single simple string identifier. It could add format guidance, but the meaning is clear.

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

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

The description clearly identifies the resource (import) and the focus (progress), and specifies the lookup key (import_id). It does not use a direct verb like 'gets' or 'returns', but the meaning is unambiguous and distinguishes it from import creation tools like sweipe_import_demo.

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

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

The phrase 'running or finished import' implies this tool is appropriate when an import already exists and the agent needs its status. However, it gives no explicit guidance on when to use this over sweipe_status or other sibling tools, and it does not state exclusions or alternatives.

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

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

No annotations are provided, so the description carries full burden. It does not disclose that the tool is read-only, nor does it mention caching behavior despite the 'refresh' parameter implying a cache. The agent is left to infer safety and side effects, which is a significant gap for a tool with no annotation support.

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, information-dense sentence that front-loads the purpose, lists the return fields, and names the companion tool. There is no extraneous text or repetition of schema details.

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 list tool with one optional parameter and no output schema, the description covers the essentials: what it returns, what it's for, and how to proceed. The only minor gap is the absence of explanation about when to use the 'refresh' parameter, though the schema covers its function.

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%: the only parameter 'refresh' is fully described as 'Bypass the cached list.' The description adds no additional meaning about the parameter, so it relies entirely on the schema, which is the baseline 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?

The description states a clear verb ('list') and resource ('ready-made demo sites'), and specifies the fields returned. It also names the companion tool sweipe_import_demo, distinguishing it from siblings like sweipe_status or sweipe_ai_library. This makes the tool's purpose unambiguous.

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

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

The description provides explicit guidance on when to use the tool: to see available demos, and directs the agent to use sweipe_import_demo with a slug for the next step. It doesn't explicitly state when not to use it, but the alternative is clearly named and the context is evident.

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

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

With no annotations, the description carries the full burden. It discloses the multi-step sequence, the conditional rebuild, and the approximate credits and time. It doesn't detail failure modes or side effects, but it covers the main behavioral characteristics.

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 core function, then cost/time, then usage guidance. No wasted words; 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?

Given the tool's complexity (multi-step loop, 4 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain parameters like 'language', doesn't clarify the 'import' step, and doesn't address potential errors or output. An agent would need more guidance to call it correctly.

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

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

Schema description coverage is only 50% (base and review have descriptions, brief and language do not). The description adds no parameter explanations, so it fails to compensate for the missing schema descriptions. The agent is left uncertain about the 'language' and 'brief' parameters.

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

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

The description explicitly states the tool performs the entire loop: plan, build, import, review, and potentially rebuild. It distinguishes itself from individual sibling tools by naming the full workflow and the condition for using them instead.

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

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

It explicitly says to use the individual tools when the plan should be edited by hand first, implying this tool is for when no manual editing is needed. This gives a clear when-to-use vs when-not-to-use directive.

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

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

With no annotations, the description carries the full burden. It says what data is reported but does not explicitly state that the call is read-only or free of side effects. The phrase 'Call this first' and the word 'status' imply a safe orientation read, so this is adequate but not fully transparent.

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 sentence that front-loads all relevant status categories and ends with a clear directive to call it first. There is no filler, repetition, or unnecessary elaboration.

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 there is no output schema, the description usefully enumerates the return content categories and gives a suggested call order. It does not specify exact response format or field names, but for a zero-parameter status tool this is adequate and leaves little ambiguity about what the agent will learn.

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 and schema description coverage is 100%, so there is nothing for the description to add about parameters. The description appropriately invents no parameter details, which matches the baseline for a parameterless 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 names the resource ('this WordPress install') and enumerates the status dimensions it reports: theme/plugin/Elementor/WooCommerce, licence activity, AI enabled/configured, and AI site plan stage. The verb is implicit rather than explicit ('status' appears in the title), but the content is specific and distinguishes this from import/AI action 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?

The description gives an explicit when-to-use instruction: 'Call this first.' This clearly positions the tool as the entry-point or orientation call before acting on the site. It does not enumerate alternatives or exclusions, but the ordering guidance supplies enough context for a zero-parameter status tool.

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 are absent, so the description bears the full burden. It identifies the REST endpoint (wp/v2/settings) and the fields returned, which implies a read operation. However, it never explicitly states that this tool is non-mutating or what response shape to expect; for a simple zero-parameter GET this is a minor gap.

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

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

A single, well-formed sentence that front-loads the resource and then gives concrete examples of the settings included. There is no filler or repetition.

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 tool, the description is largely sufficient: it names the endpoint and the contents. The only omission is an explicit statement of the return type, but with no output schema and a well-known REST resource, this is easy for an agent 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 tool takes zero parameters, so the input schema is complete at 100% coverage. The description adds no parameter details, but none are needed; baseline 4 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 the target resource (wp/v2/settings) and lists the specific fields it exposes (site title, tagline, timezone, language, front page). The verb is only implied by the tool name and REST endpoint, and it doesn't explicitly distinguish from wp_update_settings within the text, so it falls just short of a 5.

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

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

There is no guidance about when to call this tool instead of alternatives. It neither states that it is the read counterpart to wp_update_settings nor notes any conditions or prerequisites. The only usage signal is the get naming convention.

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

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

No annotations are provided, so the description bears the full burden. It discloses the output fields and implies read-only behavior by using 'list', but it does not explicitly state that it is a read operation, nor does it mention pagination, sorting, or any side effects. It also doesn't address the 'search' and 'per_page' parameters' behavior. The description adds some value but leaves significant behavioral details undisclosed.

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, concise sentence that front-loads the action and resource, then adds purpose. It contains no filler or redundancy. It is appropriately sized for a simple list operation, though it could be slightly longer to cover parameters.

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 list tool with two optional parameters and no output schema, the description covers the core purpose and returned fields, but it omits any explanation of the parameters and does not explicitly confirm read-only behavior. Given the low complexity, these gaps are noticeable but not critical. The description is adequate for basic use but leaves an agent guessing about search and pagination.

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% – the schema has no descriptions for 'search' or 'per_page'. The description does not mention either parameter or clarify what they do. It neither compensates for the schema gap nor adds any semantic meaning beyond the bare type definitions. An agent would not know how to use these parameters effectively.

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 ('list') and resource ('pages'), enumerates the returned fields (id, title, slug, link, status), and states the intended purpose ('for picking front pages and checking an import'). This clearly distinguishes it from all sibling tools, which are unrelated (settings, sweipe operations). No ambiguity about what the tool does.

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 the tool: picking front pages and checking an import. It doesn't explicitly mention alternatives or when not to use it, but the sibling list shows no competing list-pages tool, so the purpose statement effectively guides selection. Lacks an explicit exclusion clause, but the context is sufficient.

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 does not disclose behavioral traits beyond what is obvious from the verb 'change'. It does not mention whether the operation is permanent, whether it triggers side effects (like cache invalidation), or any permission requirements. Since there are no annotations at all, the description carries the full burden but fails to provide these details.

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 sentence that front-loads the verb and resource, then lists parameters with examples. Every word earns its place; no fluff. It is concise while being informative.

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 (10 parameters, no required), the description is helpful but incomplete. It explains major parameters and gives format hints, but it does not explain return values or side effects. Since there is no output schema, the description could have described what the response contains, but it doesn't.

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 schema provides no descriptions for any of the 10 parameters, so the description compensates by listing most of them with format examples (timezone, language) and enum guidance (show_on_front). It adds meaning beyond raw types, but it misses date_format, time_format, and posts_per_page, which remain undocumented entirely.

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 'Change core WordPress settings' and enumerates the specific settings it modifies (title, description, timezone, language, show_on_front, page_on_front, page_for_posts). It provides concrete examples for timezone and language formats, adding precision. It does not overlap with the sibling wp_get_settings, which is a read operation.

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

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

The description implies it's for updating WordPress settings but does not explicitly state when to use it versus alternatives. However, the sibling wp_get_settings is clearly read-only, so the purpose of update vs. get is implied. There are no alternative update tools among siblings, so no exclusions are needed.

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