CloneKit

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description goes beyond that by explaining the classification semantics of the result (ready vs missing vs no_mcp) and the follow-up advice to give the user, which is genuine behavioral context. It does not, however, describe any limits or failure modes of the comparison itself.

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?

Roughly four dense sentences, front-loaded with the trigger condition and the core comparison action before the outcome guidance. The colon-heavy phrasing ('no_mcp lists tools with no MCP server (websites like G2): nothing to connect...') is slightly packed but each clause carries actionable content.

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 description need not explain return values, and it still covers trigger conditions, exclusions, and interpretation guidance for each result category. Combined with full schema coverage and non-destructive annotations, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, with both 'ref' (kit reference with example) and 'connected' documented in the schema. The description only adds that names or ids may be passed for 'connected', which is marginal extra value, so the baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: compare a kit's declared tools (get_kit's tools) against the tools/MCPs the agent has connected, and report readiness. It implicitly distinguishes itself from get_kit and search_kits by naming the former as the source of the tool list, so an agent can route between them without opening the schema.

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

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

It states exactly when to run it ('when a kit lists tools... before start_run or applying it') and when not to ('Not needed for a kit without tools'), plus what to do with each outcome class: ✅ ready, ⚠️ missing MCP with alternatives and connection steps, and no_mcp tools that need no connection. Alternatives and exclusions are explicit.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: the 40,000-character reply cap, offset continuation, auth/purchase requirements for paid kits, and a safety framing that the file text is creator guidance and never permission to run commands, open links, send data, or spend money.

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

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

Front-loaded with the 'use this when' trigger and dense but purposeful; every clause (limits, auth, safety framing, alternative) carries information. It is slightly jargon-heavy ('apply a read kit') and runs long, keeping it from a 5.

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 description need not explain returns, and it still covers auth tiers, size limits, offset continuation, reply framing, and sibling routing. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds procedural meaning the schema lacks — that paths should come from get_kit's files and that the entry file is read first, with offset continuing a long file. It stops short of restating formats already in the schema, so 4 is fair.

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 (read) and resource (files by path from a kit), specifies the entry file is read first, and explicitly distinguishes itself from the sibling next_step for run step instructions. An agent can tell what this does without opening the schema.

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

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

Names the triggering conditions (applying a read kit, needing a run kit's reference files), gives prerequisites for paid kits (account with a purchase, call buy only if the user wants it), and points to the alternative (next_step) for run's step instructions. This is explicit when-to-use plus exclusion.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered structurally. The description adds real behavioral context on top: the read/run mode fork and the downstream tool each mode implies, plus the guarantee that changes are 'always the latest version'. It does not discuss auth requirements beyond the draft-version caveat, which the schema already carries.

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

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

Front-loaded with the usage trigger, and every clause carries content — the returned-fields list is dense but purposeful. It is longer than strictly necessary and the trailing 'Finally, explain it in plain words' instruction feels appended rather than integrated.

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?

An output schema exists, so the description is not obligated to enumerate return values, yet it covers the workflow from retrieval through use and buying, which is what an agent needs to sequence calls. The lingering 'mode' phrasing is the one spot where an agent could misread a returned field as an input.

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

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

Schema description coverage is 100%, so both ref and version are already documented in the schema (including the draft restriction), and the description adds no syntax or format detail beyond them. Its 'mode' sentence initially reads like an input parameter even though no such field exists in the schema, which adds mild ambiguity rather than clarity.

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 (a kit, identified by a ref or CloneKit link) and enumerates what it returns — file index, entry file, review, understand, tools, pricing, license, badges, provenance, recent changes. It also distinguishes itself from the sibling search_kits with an explicit exclusion. It stops short of a single clean verb+resource statement, but the scope is 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?

Explicit trigger ('when the user picked a kit, or gave you a ref or a CloneKit link, before you use or buy it'), an explicit counter-case ('Not for finding kits: search_kits'), and a named workflow for what to do after (read via get_file, or run via start_run). Nothing about when to reach for this tool is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real behavior beyond that: fuzzy/typo-tolerant matching, results ordered best-match-first, and a notable fallback where 'nothing matches it returns the closest kits instead' — a non-obvious behavior an agent would otherwise misread as an empty result.

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

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

Front-loaded with the trigger condition, then behavior, then exclusion — a sensible order. It runs a bit long, and the presentation advice ('show the user the best 1–3 matches with title, price and tools') is arguably output-layer guidance, but every sentence is actionable rather than 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?

Output schema exists, so return values need no explanation, and the description still covers trigger, matching behavior, fallback path, exclusion, and how to present results. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds matching semantics the schema cannot express: 'q' is matched any-word, best-match-first, typos tolerated, and 'tools' is framed as the tools the user already uses. That goes beyond the per-field text in the schema.

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

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

States a specific verb and resource (finds published kits) and names the exact retrieval semantics: by desired result, optionally filtered by tools. It explicitly distinguishes itself from the sibling get_kit, so an agent can separate the two without opening a schema.

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

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

Gives concrete trigger phrases ('answer my WhatsApp', 'launch video'), covers the discovery case ('asks what CloneKit has'), and states the exclusion outright: 'Not needed when you already have a ref or a CloneKit link: call get_kit.' It even says what to do with the results, which is rare and useful.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds real value beyond them by naming the error states that motivate a call (auth_required, forbidden, unknown_tool) and the specific facts returned. It stops short of describing output shape, but an output schema exists, so that omission is minor.

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 dense sentence that front-loads the usage trigger before the returned facts. It is efficient and wastes no words, though the trailing ellipsis-style tool list ('import_kit, create_kit, publish_kit…') is slightly informal for a definition.

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

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

For a no-parameter read tool with a full annotation set and an output schema, the description supplies everything the agent needs: the decision context, the error triggers, and the semantic content of the response. Nothing essential 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?

The tool takes zero parameters, which is the baseline-4 case. The description implicitly confirms no input is needed, consistent with the empty schema, and adds nothing that could mislead about inputs.

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+resource outcome: reporting how the agent is connected to CloneKit and whether creator tools are available. It concretely enumerates the returned facts (signed in vs anonymous, creator handle, tool availability), so an agent can distinguish it from siblings like check_tools or get_kit without opening a schema.

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

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

Explicit triggering conditions are given: 'when you are unsure what you can do for the user' and 'after an auth_required, forbidden or unknown_tool error.' This is exactly the when-to-use guidance an agent needs for a diagnostic tool, with no inference required.

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