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

Annotations are absent, so the description carries the full burden. It discloses the main actions (validate, accept, resume) and the state constraint, but does not explain side effects of accepting drafts (e.g., irreversibility) or failure behavior if validation fails. Adequate but not deeply 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?

Two sentences with zero waste. The main action is front-loaded in the first sentence, and the validity condition in the second provides essential context without padding.

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

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

For a state-changing pipeline tool with no output schema, it communicates the precondition, what it does, and the next step. It could mention failure semantics or side effects, but overall it is reasonably complete for a tool with full schema parameter 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% for all three parameters, so the baseline of 3 applies. The tool description itself adds no parameter-level meaning 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 states specific actions (validates imports, optionally accepts drafts, resumes pipeline) and names the exact pipeline stage and condition. It clearly distinguishes this from siblings like import_design_artifacts by describing a post-import continuation step.

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 a clear context ('only valid while paused at EXTERNAL_DESIGN') and implies it follows import_design_artifacts. However, it does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the burden. It explains what is returned (Markdown, two prompts) and their purpose, and notes the doc is for a public system, mildly implying low access friction. It does not explicitly state read-only behavior or lack of side effects, but the 'get' operation and static-doc framing keep it adequate.

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 sentence, moderately front-loaded with 'Markdown onboarding doc...' and no filler. It packs the object type, purpose, and audience into a compact structure, though the phrase 'for a public system' could be clearer as a return value rather than a modifier.

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 single-parameter getter with no output schema, the description supplies the return format (Markdown), the content (two prompts), and the use case (bootstrap/sync to Claude Design). The schema covers the parameter. Minor gap: no mention of sibling-tool boundaries, but that is already reflected in usage guidance.

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 single required parameter is 100% covered by the input schema ('System name, public slug or alias'), so the schema already carries the semantic weight. The description adds no parameter-specific detail, matching the baseline of 3 for full schema coverage.

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

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

The description names a concrete resource (a Markdown onboarding doc) and its contents (two copy-paste prompts for an external AI coding agent to bootstrap a design package and sync to Claude Design). It clearly signals this is about agent prompts, though it does not explicitly contrast with sibling tools like get_design_prompt_pack.

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 about when to prefer this tool over siblings such as get_design_prompt_pack or get_design_handoff. The intended scenario is only implied by the description (needing the agent prompt doc), with no 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 behavioral transparency. It discloses the availability windows and the JSON return shape, and 'get' implies a read operationikuha. However, it does not disclose auth requirements, failure behavior, or what happens when called outside the stated states.

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 dense sentence with no filler. The front-loaded subject and colon-structured list make the return contents immediately scannable.

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

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

With no output schema, the description compensates by itemizing the returned components and adding availability constraints. It is sufficient for an agent to call the tool correctly in the right flow state, though edge-case/error behavior is not covered.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The tool description adds no meaning about how to supply designId or handoffKey, so the baseline of 3 applies.

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

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

The description states a specific resource ('the design's continuation bundle') and its output format ('as JSON'), and enumerates the bundle's contents. It does not explicitly contrast against siblings such as get_design_prompt_pack, so it lacks a direct differentiation, but the purpose is clear.

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 conveys when the tool is usable: 'mid-flow (project paused at EXTERNAL_DESIGN) and post-completion.' This is a helpful context signal, though it does not mention exclusions or explicitly point to 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 the full behavioral burden. It does disclose two useful facts: the output is markdown and it is 'regenerated from live data on every call,' signaling non-cached, dynamic output. However, it does not disclose auth requirements, size, failure modes, or what the 'latitude contract' entails, leaving gaps for a tool with zero annotation coverage.

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 dense sentence that front-loads the core purpose before elaborating on structure. It is reasonably efficient with no filler, though the run-on sentence structure packs several ideas together and could be split for readability.

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 compensates well by detailing the return content (anchor sheet, component sheets, page prompts, latitude contract). The main gap is the absence of usage guidance and clarification of the 'latitude contract' term, but for a read-only retrieval tool of moderate complexity it covers the essentials.

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 designId and handoffKey are already fully documented in the schema. The description adds no parameter-specific meaning beyond the schema, which matches the baseline-3 expectation 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 names a specific verb-resource pair ('get design prompt pack') and describes the returned content in detail (markdown, anchor sheet, component sheets, page prompts). It implies differentiation from the sibling get_design_handoff by describing a prompt pack rather than a handoff, though it never names the alternative explicitly.

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

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

No explicit when-to-use, when-not-to-use, or alternative-routing guidance is given. The phrase 'app-authored sequential Claude Design prompt pack' hints at a context but never states when the agent should pick this over get_design_handoff or get_agent_prompt. Usage must be inferred entirely from the tool name and sibling list.

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 bears full responsibility for behavioral disclosure. It describes the manifest's contents but does not state that the operation is read-only, whether authentication or special permissions are needed, or any failure conditions. The verb 'get' hints at retrieval, but the description itself adds no safety or side-effect information.

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 with no filler. It front-loads the core concept 'Full adoption manifest' and then lists the included categories compactly, making it easy to scan and parse.

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 gives a solid inventory of the returned content and a usage constraint ('public system'). It does not specify the response format or error behavior, but the listed contents are sufficient for basic orientation and decision making.

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 covers the single parameter 'name' completely with a clear description. The tool description adds no extra parameter semantics beyond the schema, so the baseline score of 3 applies.

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

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

The description identifies the tool as returning a 'Full adoption manifest' and enumerates its specific contents (tokens, components, pages, brand asset URLs, design-direction block). This clearly differentiates it from sibling tools like get_system_tokens, which focus on a subset.

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 'Full adoption manifest' and the constraint 'for a public system' imply when this tool is appropriate, but no alternatives are named and no conditions for choosing it over siblings like get_system_tokens are stated. Usage is implied rather than 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?

With no annotations provided, the description carries a heavier burden. It adds the key behavioral detail that it calls a legacy endpoint, which is useful for understanding API compatibility. However, it doesn't disclose important aspects like whether the operation is read-only (though 'export' implies it), performance characteristics, or potential deprecation risks, leaving gaps.

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 concise, with two sentences that efficiently convey the core function and a critical implementation detail (legacy endpoint). It is front-loaded with the primary purpose. The only minor waste is the second sentence's redundancy about the endpoint, but it's valuable info for the agent.

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 is nearly complete for a simple 2-parameter export tool. It covers the formats, the endpoint type, and the parameter names. The only missing piece is the return format structure, but since there's no output schema, the agent might wonder what the response looks like, though 'export' typically implies a file or string.

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 100% description coverage, so the description itself doesn't need to repeat parameter details. The description does add context by clarifying that the format is the output format, which is helpful. Baseline 3 is appropriate since the schema already documents the parameters well, and the description's contribution is minimal but present.

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 function: exporting a system's tokens in a specified format. It distinguishes itself from sibling tools by focusing on token export, unlike get_design_handoff or get_agent_prompt. The specific list of formats adds precision, making the purpose 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 implies when to use it (when needing token exports) and mentions the legacy endpoint, but it does not explicitly state when not to use it or contrast with siblings. For instance, it doesn't say 'use this for token exports, not for design handoff'—that context is only implicit from the sibling names.

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 discloses a key trait: imported rows land as DRAFT for human review and never auto-approve. It also specifies accepted formats for each artifact type (self-contained HTML, standalone HTML, PNG base64/URL), which is important behavioral detail. It does not mention potential side effects like duplicate handling or overwriting, but the described behavior is substantial and non-contradictory.

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 first sentence front-loads the purpose and key behavioral outcome (DRAFT, no auto-approve). The second efficiently enumerates artifact format expectations. Every clause adds value, and nothing is redundant 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?

Given the tool's complexity (6 parameters, nested arrays, no output schema, no annotations), the description covers the essential aspects: what the tool does, how results are handled, and what each artifact type should look like. It doesn't delve into the exact meaning of 'carrier project' or the handoffKey fallback, but the schema provides some of that, and the core invocation requirements are clear enough for correct use. A 4 reflects that it is nearly complete for practical purposes.

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 50%, and the description meaningfully enriches the main artifact parameters. It explains that components are self-contained HTML with inline styles, pages are standalone HTML documents, and assets are PNG base64 or URL with optional sourceCode—details absent from the schema. This helps agents understand what to provide for the 'code' and 'dataBase64' fields. It doesn't cover every parameter, but the most complex ones are clarified.

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 verb and resource: 'Import externally designed work back into DesignFlow.' It also clarifies the immediate result ('Rows land as DRAFT... nothing auto-approves'), which distinguishes it from the getter-style sibling tools like get_design_handoff or get_design_prompt_pack. This is unambiguous and separable.

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: when returning externally designed work into DesignFlow. It doesn't explicitly name alternatives or exclusions, but among the sibling tools there is no direct import alternative, so the intended use is evident. A 4 is appropriate because context is clear, though no explicit when-not 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?

No annotations are present, so the description carries the full burden for behavioral disclosure. 'List' implies a read operation, but the description does not state that it is read-only, safe, or free of side effects, nor does it mention authentication or response size. An agent gets no behavioral clarity beyond the verb 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?

A single, front-loaded sentence that states the action, resource, and return fields with zero filler. Every word adds value.

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 list tool, the description fully specifies the resource and the fields returned. There is no output schema, so this is sufficient for an agent to call the tool and interpret the result. No missing context is apparent.

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 correctly focuses on what the tool returns rather than parameters, and no parameter semantics are needed.

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 the specific verb 'List', names the resource 'public design systems in the BrandPilot pool', and enumerates the returned fields. This cleanly distinguishes it from the more targeted sibling tools like get_system_tokens or get_system_adoption.

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

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

Usage is implied: call this when you need an overview of all public design systems. However, it does not explicitly mention when not to use it or name alternative sibling tools, so guidance beyond the obvious is absent.

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