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 effectively describes what the tool does (analyzes structure, identifies sections, detects transitions, groups icons, estimates tokens, recommends agent count) and includes a workflow section, though it lacks details on error handling, performance, or rate limits. No contradictions exist.

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 well-structured with clear sections ('HOW IT WORKS', 'RETURNS', 'TYPICAL WORKFLOW'), front-loaded with key information, and every sentence adds value without redundancy. It efficiently communicates complex functionality in a digestible format.

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 (structural analysis with multiple outputs), no annotations, and no output schema, the description provides comprehensive context: it details the analysis process, lists all return fields with explanations, and includes a workflow for integration with sibling tools. This compensates well for the lack of structured data.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description does not add any specific meaning or usage details beyond what the schema provides, such as explaining how partial matches work or providing examples. Baseline 3 is appropriate when 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 explicitly states the tool analyzes page structure before implementation, identifies sections by background color changes, detects transition elements, groups icons, estimates tokens, and recommends agent count. It clearly distinguishes from siblings like get_frame_info or get_section_screenshot by focusing on structural analysis for workflow planning.

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 usage guidance: 'MUST BE CALLED FIRST for any large page/frame' and includes a 'TYPICAL WORKFLOW' section detailing when to use this tool versus alternatives like get_section_screenshot and get_agent_context, specifying conditional logic based on the output.

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 does an excellent job describing key behaviors: progress tracking with specific output format, automatic categorization into folders, smart naming, composite group handling, and final summary. It even provides implementation details ('Look for "isCompositeAsset: true"'). The only minor gap is lack of explicit mention about permissions or error handling.

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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW') and uses bullet points effectively. While slightly longer than minimal, every sentence adds value. The front-loading of the core purpose is excellent, though the workflow section could be slightly more concise.

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

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

For a complex asset extraction tool with no annotations and no output schema, the description provides substantial behavioral context. It explains the extraction process, categorization, naming, progress reporting, and provides a workflow. The main gap is the lack of explicit information about return values/output format, though the 'final summary' hint partially addresses this.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain format requirements for file_key or matching behavior for page_name/frame_name). However, it does provide context about the output_dir's purpose through the workflow example.

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 specific action ('extract all assets') and resource ('from a frame'), distinguishing it from siblings like 'extract_styles' or 'get_screenshot'. It explicitly mentions what types of assets are extracted (icons, images, composites) and how they're processed, providing clear differentiation from other tools.

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

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

The 'TYPICAL WORKFLOW' section explicitly states when to use this tool ('extract_assets → download all') and provides a clear prerequisite ('get_frame_info → see what assets exist and identify composite groups'). It also implies when not to use it (e.g., for styles extraction or screenshots, which are handled by sibling tools).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: what gets extracted (design tokens like colors, fonts), the output format (organized JSON), and a performance characteristic ('No chunking needed'). It doesn't mention error conditions, rate limits, or authentication needs, but provides substantial operational context beyond basic purpose.

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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW'), front-loads the core purpose, and every sentence adds value. It efficiently communicates essential information without redundancy, making it easy for an agent to parse and understand.

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 moderate complexity (3 parameters, no output schema, no annotations), the description provides strong contextual completeness. It explains what the tool does, how it works, and typical usage. The main gap is the lack of output schema, so the description doesn't detail the JSON structure, but it adequately covers the tool's role and behavior for agent selection.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain how partial matching works for page_name/frame_name). However, it does provide context about what the tool does with these parameters, maintaining 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 specific action ('Extract all design tokens from a frame') and distinguishes it from siblings like 'get_file_styles' (which likely extracts global styles) or 'analyze_page_structure' (which focuses on layout). It explicitly mentions the resources being extracted (colors, fonts, spacing, etc.) and the output format (JSON for CSS/theme generation).

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 this tool through the 'TYPICAL WORKFLOW' section, which positions it after 'get_frame_info' to understand structure and before using tokens for theme/CSS. It implicitly distinguishes from siblings by focusing on frame-level design tokens rather than page structure or global styles, though it doesn't explicitly name 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 burden. It discloses behavioral traits: it returns context for a single agent (not all agents), handles responsibilities (implementation vs. coordination), includes specific data types (icons, styles, transition elements), and generates agent-specific instructions with coordination rules. However, it doesn't mention error handling, rate limits, or authentication needs, which are gaps for a tool with no annotations.

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

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

The description is well-structured with sections (HOW IT WORKS, RETURNS, TYPICAL WORKFLOW) and uses bullet points for clarity. It is appropriately sized, but some sentences could be more concise (e.g., 'Handles responsibilities: what to implement vs coordinate' is slightly redundant). Overall, it's efficient with minimal waste.

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

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

Given the complexity (6 parameters, no annotations, no output schema), the description is fairly complete. It explains the tool's role in a workflow, what it returns, and how to use it. However, without an output schema, it doesn't detail the return format (e.g., structure of 'section' or 'instructions'), which is a gap. It compensates by listing return components but lacks depth on their semantics.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal value beyond the schema: it mentions 'sectionId' and 'agentIndex' in the workflow but doesn't explain their semantics further (e.g., how sectionId relates to analyze_page_structure output). With high schema coverage, the baseline is 3, and the description doesn't significantly enhance parameter understanding.

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: 'Prepare agent context for parallel implementation of a section.' It specifies the verb ('prepare') and resource ('agent context') with a specific scope ('for parallel implementation of a section'). It distinguishes from siblings like analyze_page_structure (which identifies sections) and get_section_screenshot (which provides visual references).

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 this tool: 'Call after analyze_page_structure to identify sections' and 'For each section: get_section_screenshot → visual reference' then 'get_agent_context(sectionId, agentIndex) → agent-specific context.' It includes a TYPICAL WORKFLOW section that outlines the sequence and alternatives (e.g., using get_section_screenshot for visual reference).

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 effectively describes key behavioral traits: what it returns (design system tokens), that these are 'official styles defined in Figma', and output characteristics ('Compact output, no chunking needed'). It doesn't mention error conditions, rate limits, or authentication needs, but provides substantial context beyond basic functionality.

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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW'), front-loaded with the core purpose, and every sentence adds value. It efficiently communicates purpose, behavior, and usage guidelines without redundancy or unnecessary information.

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

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

Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is quite complete. It explains what the tool does, how it works, output characteristics, and how it fits into workflows. The main gap is lack of explicit error handling or return format details, but for a read-only tool with good behavioral description, this is minor.

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 with the 'file_key' parameter clearly documented as 'Figma file key'. The description doesn't add any additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage. No compensation is needed since schema coverage is complete.

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: 'Get all published styles defined in the file' with specific details about what it returns ('design system tokens: colors, text styles, effects') and distinguishes it from sibling tools like 'extract_styles' which is for frame-specific tokens. It explicitly names the resource (styles/tokens) and verb (get).

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 this tool versus alternatives, particularly in the 'TYPICAL WORKFLOW' section which states: '1. get_file_styles → global design tokens 2. extract_styles(frame) → frame-specific tokens 3. Combine for complete design system'. This clearly differentiates it from 'extract_styles' and explains the complementary relationship.

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 full burden and provides substantial behavioral context: it describes return content (components, text, colors, styles), handling of large frames (warning with strategy), chunking behavior, and special markers (isCompositeAsset, isSmallElement). It doesn't mention rate limits or authentication needs, but covers most operational behaviors well.

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?

Well-structured with clear sections (IMPORTANT, HOW IT WORKS, TYPICAL WORKFLOW) and front-loaded key information. Some sentences could be more concise (e.g., the workflow section is somewhat redundant with earlier guidance), but overall it's efficiently organized with minimal waste.

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 5 parameters, no annotations, and no output schema, the description provides good contextual coverage: purpose, sequencing, behavioral traits, and workflow integration. It doesn't fully describe the return format or error conditions, but given the complexity and lack of structured fields, it's reasonably complete for agent use.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters. The description adds some context about the depth parameter ('control detail level') and implies frame_name comes from list_frames, but doesn't provide additional syntax or format details beyond what the schema provides. Baseline 3 is appropriate when 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 clearly states the tool's purpose with specific verbs ('Get detailed info') and resource ('about a specific frame'). It distinguishes from siblings by focusing on frame-level details rather than page analysis (analyze_page_structure), asset extraction (extract_assets), or listing (list_frames). The opening sentence directly answers 'what does this tool do?'

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 guidance is provided: 'This should be your FIRST call for any implementation task' and 'Always call get_frame_info BEFORE taking screenshots'. The TYPICAL WORKFLOW section shows sequencing with list_frames and other tools. Clear when-to-use context is established, though alternatives aren't explicitly named.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a read operation (implied by 'Get'), returns comprehensive data (listed in 'WHAT YOU GET IN ONE CALL' and 'RETURNS'), and supports parallel implementation workflows. However, it lacks details on error handling, rate limits, or authentication needs, which are important for a tool with multiple parameters and no output schema.

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 well-structured with clear sections (WHAT YOU GET, PERFECT FOR, RETURNS, TYPICAL WORKFLOW), making it easy to scan. It's appropriately sized for a complex tool, though some redundancy exists (e.g., listing items in both 'WHAT YOU GET' and 'RETURNS'). Most sentences earn their place by adding value, but minor trimming could improve conciseness.

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 (4 parameters, no annotations, no output schema), the description does a good job of explaining what the tool does, when to use it, and what it returns. It covers purpose, usage guidelines, and behavioral context comprehensively. However, the lack of an output schema means the description must fully explain return values, which it does in the 'RETURNS' section, though some details (e.g., data formats for screenshots) could be more explicit.

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, providing clear documentation for all 4 parameters (file_key, page_name, frame_name, scale). The description adds no additional parameter-specific information beyond what's in the schema. According to the rules, when schema_description_coverage is high (>80%), the baseline score is 3 even with no param info in the description, which applies here.

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 'Get complete page context in ONE call with all sections, assets, screenshots, and styles.' It uses specific verbs ('Get complete page context') and resources ('sections, assets, screenshots, and styles'), clearly distinguishing it from siblings like get_screenshot (single screenshot) or extract_assets (assets only). The 'ONE call' emphasis highlights its comprehensive nature versus piecemeal alternatives.

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

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

The description provides explicit usage guidance with sections like 'PERFECT FOR:' and 'TYPICAL WORKFLOW:'. It specifies when to use ('Getting full context before implementation', 'Preparing data for parallel multi-agent work') and implies alternatives by contrasting its 'ONE call' approach with sibling tools that handle specific aspects (e.g., extract_assets, get_screenshot). The workflow steps outline a clear sequence, reinforcing its role in multi-agent scenarios.

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 key behavioral traits: automatic segmentation for large frames, returns base64 image(s), and scale control for resolution. However, it lacks details on error handling, performance implications, or specific output format beyond 'base64 image(s).'

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 well-structured with clear sections (WARNING, HOW IT WORKS, TYPICAL WORKFLOW), front-loaded with critical usage guidance. Every sentence earns its place by providing essential information without redundancy, making it efficient and easy to 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?

Given no annotations and no output schema, the description does a good job covering purpose, usage, and key behaviors. However, it lacks details on the output format (e.g., structure of returned images, pagination for tiles) and error cases, which are important for a tool with visual output and segmentation logic.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal value beyond the schema, mentioning that scale controls resolution and segmentation occurs for large frames, but doesn't provide additional syntax or format details. Baseline 3 is appropriate as 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 clearly states the tool's purpose with the specific verb 'capture' and resource 'screenshot of a frame.' It distinguishes from siblings like get_frame_info (which provides structure details) and get_section_screenshot (which might target sections rather than frames), making the scope explicit.

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 this tool, including a WARNING not to use it as a first step and to always call get_frame_info first. It outlines a typical workflow with alternatives (list_frames, get_frame_info) and distinguishes from other tools by emphasizing its role for visual reference after understanding the structure.

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 effectively describes key behaviors: 'Makes other sections transparent (shows only target section),' 'Optionally includes transition elements context,' and 'Returns cropped image focused on section.' However, it lacks details on error handling, performance, or authentication needs, preventing a perfect score.

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 well-structured with clear sections ('HOW IT WORKS,' 'TYPICAL WORKFLOW') and uses bullet points for readability. It is appropriately sized, though the workflow section is slightly verbose. Most sentences earn their place by adding practical guidance, but minor trimming could improve conciseness.

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, no output schema, no annotations), the description is largely complete. It explains the tool's purpose, usage workflow, and key behaviors. However, without an output schema, it doesn't detail the return format (e.g., image type, size), leaving a minor gap in contextual coverage.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema, mentioning 'sectionId' and 'transition elements context' but not providing additional syntax or format details. This meets 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 tool's purpose: 'Capture screenshot of a specific section within a frame.' It specifies the verb ('capture'), resource ('screenshot'), and scope ('specific section within a frame'), distinguishing it from sibling tools like 'get_screenshot' (which likely captures entire frames) and 'analyze_page_structure' (which identifies sections).

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 and how to use this tool. It states: 'First call analyze_page_structure to identify sections' and outlines a 'TYPICAL WORKFLOW' with step-by-step instructions, including alternatives like 'get_frame_info with section context.' This clearly differentiates it from other tools and provides practical 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 provided, the description carries the full burden of behavioral disclosure. It adds value by specifying the return structure (e.g., 'Current file being explored', 'Pages and frames already sent'), which helps understand what data is retrieved. However, it doesn't cover aspects like performance, error handling, or session state mutability, leaving gaps for a debugging tool.

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

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

The description is well-structured with a clear purpose statement followed by a bulleted list of return items, making it easy to scan. It's appropriately sized for a no-parameter tool, though the 'RETURNS:' label could be integrated more seamlessly into the flow.

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 simplicity (0 parameters, no annotations, no output schema), the description is reasonably complete. It explains the purpose, provides debugging context, and details return values, which is sufficient for this use case. However, it could benefit from more explicit usage guidelines relative to siblings.

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 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics by detailing return values, which compensates for the lack of an output schema. This adds meaningful context beyond the empty input 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 tool's purpose with the verb 'Get' and resource 'current session state', and specifies it's 'for debugging'. However, it doesn't explicitly differentiate from sibling tools like 'get_agent_context' or 'get_full_page_context' that might also retrieve session-related information, preventing a perfect score.

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 minimal guidance by mentioning 'for debugging', which implies usage context but doesn't specify when to use this tool versus alternatives like 'get_agent_context' or 'reset_session'. No explicit when/when-not instructions or alternative tool references are included.

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 and adds valuable behavioral context beyond the schema: it explains partial matching for page names, automatic chunking for large pages (>50 frames), the return format ('compact list with frame names, sizes, and IDs'), and session persistence ('Session remembers what was sent'). It doesn't cover error cases or rate limits, but provides substantial operational 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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW') and front-loaded with the core purpose. Each sentence adds value, though the workflow section is somewhat lengthy; it could be slightly more concise while retaining clarity.

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 no annotations and no output schema, the description does a good job of covering key aspects: purpose, usage guidelines, behavioral traits, and parameter context. It explains the return format and session behavior, which compensates for the lack of output schema. However, it doesn't detail error handling or authentication needs, leaving minor 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%, so the schema already documents all three parameters. The description adds some context: it mentions partial match support for 'page_name' (implied in schema but reinforced) and explains the purpose of 'continue' in relation to chunking. However, it doesn't provide significant additional meaning beyond what the schema offers, meeting the baseline for high 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 clearly states the specific action ('List frames/screens'), target resource ('in a specific page'), and distinguishes from siblings like 'list_pages' (which lists pages) and 'get_frame_info' (which provides detailed info on a single frame). The opening sentence is precise and 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 'TYPICAL WORKFLOW' section explicitly provides step-by-step guidance on when to use this tool versus alternatives: first use 'list_pages' to find a page name, then 'list_frames' to see frames, followed by 'get_frame_info' for details or 'extract_assets' for assets. This clearly defines the tool's role in the workflow.

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 full burden and adds valuable behavioral context: it discloses the return format ('compact JSON with page names, IDs, and frame counts'), pagination behavior for large files ('automatically chunked' for >50 pages), and how to handle continuation ('Use 'continue: true' to get next batch'). It doesn't mention rate limits or auth needs, but covers key operational 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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW'), front-loaded with the core purpose, and every sentence earns its place by adding operational guidance or workflow context without redundancy.

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

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

For a read-only listing tool with no output schema, the description is quite complete: it explains purpose, behavior, parameters, and integration with siblings. It could slightly improve by explicitly stating it's a read operation (implied but not stated) or mentioning error cases, but covers most needs given the 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?

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds marginal value by explaining the 'continue' parameter's purpose in the 'HOW IT WORKS' section, but doesn't provide additional syntax or format details beyond what the schema specifies. 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 specific action ('List all pages'), target resource ('in a Figma file'), and distinguishes from siblings like 'list_frames' and 'get_frame_info' by focusing on pages rather than frames. The opening sentence is direct and 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 'TYPICAL WORKFLOW' section explicitly provides when to use this tool (step 1 to see all pages) and what to do next (steps 2-3 with sibling tools 'list_frames' and 'get_frame_info'). This gives clear context and alternatives for related tasks.

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 effectively explains key traits: it returns the 'exact same response from session state,' involves 'No Figma API call needed,' and is 'Useful for context recovery.' This covers the read-only, non-destructive nature and performance benefits, though it could add more on error handling or state persistence.

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 well-structured with clear sections ('HOW IT WORKS,' 'WHEN TO USE'), front-loaded key information, and uses bullet points for readability. Every sentence adds value without redundancy, making it efficient and easy to scan for an AI 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?

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is nearly complete. It explains what the tool does, when to use it, and its behavioral traits. A minor gap is the lack of detail on what happens if no previous response exists, but overall it provides sufficient context for effective use.

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 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately avoids discussing parameters, focusing instead on functionality. A baseline of 4 is applied as it compensates well for the lack of parameters by explaining the tool's behavior clearly.

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 with a specific verb ('Repeat') and resource ('last response'), distinguishing it from all sibling tools which involve API calls to Figma for data retrieval or analysis. It explicitly notes it operates on 'session state' rather than making new API calls, making its unique function immediately apparent.

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 includes an explicit 'WHEN TO USE' section that provides clear guidance: use when 'Lost context and need to see previous data' or 'Want to reference last response again.' This directly addresses when to choose this tool over alternatives (like re-fetching data via API calls), with no misleading exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool 'clear[s] all session state', implying a destructive mutation, but doesn't detail what 'session state' includes (e.g., cached data, user context) or any side effects like resetting authentication or rate limits. It adds some context but lacks depth on behavioral traits.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a bulleted list for usage guidelines. Every sentence earns its place by adding value without redundancy, making it efficient and well-structured for quick understanding.

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 low complexity (0 parameters, no output schema) and lack of annotations, the description is mostly complete: it states the purpose, provides usage guidelines, and implies behavior. However, it could enhance completeness by specifying what 'session state' entails or confirming no output, but it's adequate for this simple tool.

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?

There are 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't mention parameters, which is appropriate. Baseline for 0 params is 4, as it avoids unnecessary details while being complete 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 clearly states the tool's purpose with the verb 'clear' and resource 'session state', plus the outcome 'for fresh start'. It distinguishes from siblings like get_session_state (which reads state) by focusing on resetting. However, it doesn't explicitly contrast with all siblings (e.g., repeat_last might also involve session handling), keeping it from a perfect 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?

The description includes a 'USE WHEN' section with three explicit scenarios: switching files, re-exploring from scratch, and handling corrupted state. This provides clear guidance on when to invoke this tool versus alternatives, such as using get_session_state to check state first or other tools for specific file operations.

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 and does well by disclosing key behavioral traits: result limits (top 20 with total count), pagination mechanism ('continue: true'), and refinement suggestions for large result sets. It doesn't mention rate limits, authentication needs, or error conditions, but covers core operational behavior adequately.

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 well-structured with clear sections ('HOW IT WORKS', 'TYPICAL WORKFLOW'), front-loaded with the core purpose, and every sentence adds practical value without redundancy. It's appropriately sized for a 5-parameter search 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?

Given the complexity (search with filters and pagination), no annotations, and no output schema, the description does a good job covering key aspects: purpose, behavioral constraints, and usage workflow. It could improve by detailing the output format or error cases, but it's largely complete for guiding effective use.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond the schema, mentioning 'continue: true' for pagination and implying usage of 'page_name' and 'type' for refinement, but doesn't provide additional syntax or format details. Baseline 3 is appropriate when 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 clearly states the tool searches for components by name across a Figma file, with specific details about scope (entire file or specific page) and resource (components). However, it doesn't explicitly differentiate from sibling tools like 'list_frames' or 'analyze_page_structure' beyond the search functionality.

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 'TYPICAL WORKFLOW' section provides clear context for when to use this tool in a sequence (search, refine, get details) and mentions refinement options when results exceed 20. It doesn't explicitly state when NOT to use it or name specific alternatives among siblings, but the workflow guidance is practical.

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