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

With no annotations provided, the description carries the full burden. It discloses that the tool fetches and returns data (implying read-only behavior) and specifies the structured output format, which is helpful. However, it doesn't mention potential limitations like authentication needs, rate limits, or error conditions, leaving some behavioral aspects unclear.

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 action and output, followed by a brief usage tip. Both sentences earn their place by clearly stating what the tool does and when to use it, with no redundant or vague language. It's efficiently 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 moderate complexity (fetching and summarizing a diagram), no annotations, and no output schema, the description does well by specifying the return content. However, it could be more complete by detailing the exact structure of the summary or potential errors, though the lack of output schema means some gaps are inherent.

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% coverage for its single parameter (diagram_id), so the baseline is 3. The description adds value by contextualizing the parameter as referring to a 'saved diagram to summarise,' reinforcing its purpose. However, it doesn't provide additional details like format examples or constraints beyond what the schema already covers.

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 ('fetch a saved CloudForge diagram and return a structured summary') and distinguishes it from siblings by specifying what it returns (resource count by category, most-connected components, cloud provider, and Mermaid diagram). It uses precise verbs and identifies the exact resource being operated on.

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

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

The description provides clear context for when to use this tool ('ideal for quickly understanding an architecture'), which implies it's for analysis rather than creation or modification. However, it doesn't explicitly state when not to use it or name specific alternatives among the sibling tools, though the context suggests it's distinct from operations like delete_diagram or generate_terraform.

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 but only states the action without disclosing behavioral traits like required permissions, whether the cancellation is reversible, rate limits, or what happens after cancellation. 'Cancel' implies a mutation, but no safety or side-effect details are given, leaving significant 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 a single, front-loaded sentence with zero waste—every word contributes directly to explaining the tool's purpose. It's appropriately sized for a simple tool with one parameter and no complex behavior to elaborate.

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 mutation nature (cancel), lack of annotations, and no output schema, the description is incomplete. It doesn't cover permissions, side effects, return values, or error conditions, which are critical for an agent to use this tool correctly in context with siblings like cloudforge_invite_member.

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 fully documents the single parameter (invitation_id as UUID). The description adds no additional parameter semantics beyond what's in the schema, but with 0 parameters needing extra explanation, a baseline of 4 is appropriate as no compensation is required.

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 ('Cancel') and resource ('pending organisation invitation by its ID'), distinguishing it from siblings like cloudforge_invite_member (create) and cloudforge_list_invitations (list). It uses precise terminology that directly conveys the tool's function.

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 usage when there's a pending invitation to cancel, but provides no explicit guidance on when to use this versus alternatives like cloudforge_remove_member (for existing members) or prerequisites. It mentions 'pending' which helps differentiate from non-pending states, but lacks explicit when/when-not instructions.

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 mentions the tool's purpose but lacks behavioral details such as response format, latency, rate limits, authentication requirements, or whether it's a read-only or state-changing operation. The description doesn't contradict annotations (none exist), but it provides minimal behavioral context beyond the basic function.

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, front-loaded with the core action and followed by specific use cases. Every sentence earns its place by clarifying purpose and context without redundancy or unnecessary details, making it efficient and well-structured.

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 (simple chat interface with 2 parameters) and lack of annotations/output schema, the description is adequate but incomplete. It covers purpose and usage context but misses behavioral details like response handling or error conditions. For a tool with no structured safety or output info, more completeness would enhance agent understanding.

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 (message and provider). The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't elaborate on message format or provider usage). With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.

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 ('Send a message') and target resource ('CloudForge AI Architect'), with explicit examples of use cases (IaC advice, best practices, cost optimisation, security reviews, cloud infrastructure questions). It distinguishes from sibling tools like cloudforge_generate_terraform or cloudforge_export_terraform_from_diagram by focusing on conversational advice rather than code generation or diagram operations.

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

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

The description provides clear context for when to use this tool ('Use for IaC advice, best practices, cost optimisation, security reviews, or any cloud infrastructure question'), giving specific domains. However, it doesn't explicitly state when NOT to use it or name alternatives among sibling tools (e.g., when to use cloudforge_generate_terraform instead for code generation).

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action is 'permanently delete,' which implies a destructive, irreversible operation, but doesn't cover other critical aspects like authentication requirements, error handling, or confirmation steps. This leaves significant gaps in understanding the tool's behavior.

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, efficient sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded with the key action and resource, making it easy to parse quickly.

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 of a destructive deletion operation with no annotations and no output schema, the description is insufficient. It lacks details on permissions, side effects, return values, or error conditions, which are crucial for safe and effective tool invocation in this context.

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

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

The input schema has 100% description coverage, with the 'diagram_id' parameter fully documented as a UUID. The description adds no additional semantic details beyond what the schema provides, such as format examples or validation rules, so it meets the baseline for high schema coverage without enhancing 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 action ('permanently delete') and the resource ('a saved diagram by its ID'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'cloudforge_remove_member' or 'cloudforge_cancel_invitation', which might also involve deletion operations in different contexts.

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 no guidance on when to use this tool versus alternatives. For example, it doesn't mention if this should be used instead of other deletion-related tools or if there are prerequisites like confirming ownership. Without such context, the agent lacks clear usage instructions.

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 the output behavior ('renders visually inside Claude', 'grouped by category'), but lacks details on potential errors (e.g., invalid diagram_id), performance aspects, or authentication requirements. It adequately covers the core behavior but misses some operational context.

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 valuable context about visualization and resource grouping. Every sentence adds meaningful information without redundancy, making it efficient and well-structured for quick comprehension.

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

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

For a single-parameter tool with no annotations and no output schema, the description does a good job explaining what the tool does and its visual output. However, it could be more complete by mentioning the return format (e.g., Mermaid code vs. image) or error handling, given the lack of structured output documentation.

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 single parameter 'diagram_id' clearly documented. The description doesn't add any parameter-specific information beyond what the schema provides, such as format examples or sourcing details. This meets the baseline for high schema coverage but doesn't 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 specific action ('Fetch a saved CloudForge diagram and render it as a Mermaid flowchart'), identifies the resource ('CloudForge diagram'), and distinguishes it from siblings like 'cloudforge_get_diagram' by emphasizing the Mermaid visualization output. The mention of visual rendering inside Claude and resource categorization further clarifies its unique purpose.

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

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

The description provides clear context for when to use this tool ('this is the best way to SHOW a diagram'), implying it's for visualization rather than data retrieval or editing. However, it doesn't explicitly state when not to use it or name alternatives like 'cloudforge_get_diagram' for raw data access, leaving some room for improvement in sibling differentiation.

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 mentions the tool 'generates Terraform HCL' in 'one step', implying a combined fetch-and-generate operation, but lacks details on permissions, rate limits, error handling, or output format. While it adds some behavioral context, it doesn't fully compensate for the missing 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 two sentences, front-loaded with the core functionality and followed by usage guidance. Every sentence earns its place with no wasted words, making it highly 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 2 parameters with full schema coverage, no output schema, and no annotations, the description provides a clear purpose and usage guidelines. However, as a tool that generates code (a complex operation), it lacks details on output format (e.g., raw HCL, file, or structured data) and potential side effects, leaving some gaps in completeness.

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 doesn't add any parameter-specific information beyond what's in the schema, such as format examples or constraints. Baseline 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 clearly states the tool's purpose with specific verbs ('fetch' and 'generate') and resources ('saved CloudForge diagram' and 'Terraform HCL'), distinguishing it from siblings like cloudforge_generate_terraform (which likely generates from scratch) and cloudforge_get_diagram (which only fetches).

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

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

The description explicitly states when to use this tool ('when the user wants IaC code for an existing saved diagram'), providing clear context for its application. This helps differentiate it from alternatives like cloudforge_generate_terraform (for new diagrams) or cloudforge_diagram_to_mermaid (for different output formats).

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

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

No annotations are provided, so the description carries full burden. It mentions the output ('ready-to-use .tf files') but lacks details on behavioral traits such as error handling, rate limits, authentication needs, or whether the generation is idempotent. For a generation tool with zero annotation coverage, this is a significant gap.

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

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

The description is front-loaded and concise with two sentences that efficiently convey the tool's function and output without unnecessary details. Every sentence earns its place by specifying input type, output format, and provider scope.

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 (generating Terraform code from natural language) and lack of annotations or output schema, the description is moderately complete but could improve by addressing behavioral aspects like error cases or output structure. It covers the basic purpose and parameters but leaves gaps in operational 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 all parameters thoroughly. The description adds minimal value beyond the schema by implying the 'description' parameter should include details like region and SKU preferences, but does not 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's purpose with specific verbs ('Generate Terraform HCL') and resources ('.tf files for Azure, AWS, or GCP'), distinguishing it from siblings like 'cloudforge_export_terraform_from_diagram' by focusing on natural-language input rather than diagram-based 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 implies usage context by specifying it generates from 'natural-language architecture description' and targets specific cloud providers, but does not explicitly state when to use this tool versus alternatives like 'cloudforge_export_terraform_from_diagram' or 'cloudforge_import_terraform', which are related but distinct 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?

No annotations are provided, so the description carries full burden. It discloses the return format (JSON with nodes, edges, configurations) but doesn't mention authentication needs, rate limits, error handling, or whether it's a read-only operation. For a fetch tool with no annotations, this is adequate but lacks behavioral 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 two concise sentences with zero waste: the first states the purpose, and the second specifies the return format. It's front-loaded and appropriately sized for a simple fetch 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 tool's low complexity (one parameter, no output schema, no annotations), the description is reasonably complete. It covers purpose and return format, but could improve by adding error cases (e.g., invalid ID) or behavioral context. No output schema exists, so describing returns is valuable.

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 the single parameter 'diagram_id' as a UUID. The description adds no additional meaning beyond what's in the schema, such as format examples or validation rules, 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 ('Fetch'), the resource ('a saved diagram by ID'), and the return format ('full JSON: nodes, edges, resource configurations'). It distinguishes from siblings like 'cloudforge_list_diagrams' (which lists diagrams) and 'cloudforge_diagram_to_mermaid' (which converts diagrams).

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 usage when a specific diagram ID is known, but doesn't explicitly state when to use this tool versus alternatives like 'cloudforge_list_diagrams' (to find IDs) or 'cloudforge_recent_diagrams' (for recent ones). No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's behavior (parsing HCL to produce a diagram and Mermaid preview) but lacks details on error handling, performance characteristics, or what the 'diagram structure' output entails. For a tool with no annotations, this is a moderate disclosure level.

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, front-loaded with the core purpose followed by usage guidance. Every sentence earns its place with no wasted words, making it highly 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 the tool's moderate complexity (parsing HCL to produce visual outputs), no annotations, and no output schema, the description is reasonably complete. It covers purpose, usage, and output types but could benefit from more detail on the 'diagram structure' format or error cases. It's adequate but not exhaustive.

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 the single parameter 'hcl' well-documented in the schema. The description adds no additional parameter semantics beyond implying the HCL should be from '.tf files', which is minimal value. Baseline 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 clearly states the tool's purpose: 'Parse existing Terraform HCL and return a diagram structure plus an inline Mermaid preview.' It specifies the verb (parse), resource (Terraform HCL), and output (diagram structure + Mermaid preview). It distinguishes from siblings like cloudforge_generate_terraform (which creates Terraform) and cloudforge_diagram_to_mermaid (which converts diagrams to Mermaid).

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

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

The description explicitly states when to use this tool: 'Use when the user has .tf files and wants to visualise or understand their infrastructure.' This provides clear context for usage and implicitly excludes scenarios where users don't have Terraform files or want other operations like generating or exporting Terraform.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Send an organisation invitation email') which implies a write operation, but lacks critical details like whether this requires specific permissions, what happens on success/failure, if it's idempotent, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, with every word earning its place in conveying the core functionality.

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 mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the invitation email contains, how the recipient accepts it, what happens after sending (e.g., pending invitation status), or error conditions. Given the complexity of member invitation workflows, more contextual information is needed.

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 all parameters clearly documented in the schema itself (email, first_name, last_name, role with enum). The description adds no additional parameter semantics beyond what's already in the structured schema, so it meets the baseline of 3 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 clearly states the action ('Send an organisation invitation email') and the target system ('via CloudForge'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'cloudforge_cancel_invitation' or 'cloudforge_list_invitations', which would require explicit comparison for a score of 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 offers no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., admin permissions), when not to use it (e.g., for existing members), or explicit alternatives like 'cloudforge_list_invitations' for checking status. This leaves the agent without contextual usage cues.

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 mentions the return data (IDs, names, providers, last-modified dates), which is helpful, but does not disclose behavioral traits such as pagination, error handling, authentication requirements, or rate limits. For a list operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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, efficient sentence that front-loads the purpose and includes key return details. There is no wasted verbiage, and every part of the sentence adds value, making it highly concise and well-structured.

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 (one optional parameter) and high schema coverage, the description is adequate but not complete. It lacks output schema, so the description's mention of return fields is helpful, but it does not cover behavioral aspects like pagination or error handling. For a list tool with no annotations, it should provide more context on how results are structured or limited.

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 the 'limit' parameter with its default value. The description does not add any parameter-specific information beyond what the schema provides, such as constraints or usage examples. Baseline 3 is appropriate when the schema handles parameter documentation adequately.

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 verb ('List') and resource ('saved diagrams for the current user'), and specifies the scope ('for the current user'). It distinguishes from siblings like 'cloudforge_recent_diagrams' by focusing on all saved diagrams rather than recent ones, and from 'cloudforge_get_diagram' by listing multiple items rather than fetching a single one.

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 usage for retrieving saved diagrams, but does not explicitly state when to use this tool versus alternatives like 'cloudforge_recent_diagrams' or 'cloudforge_get_diagram'. It provides context ('for the current user') but lacks explicit guidance on exclusions or prerequisites.

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

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

No annotations are provided, so the description carries full burden. It states this is a list operation, implying read-only behavior, but doesn't disclose critical details like whether it requires admin permissions, how results are paginated or sorted, or if there are rate limits. For a tool with zero annotation coverage, this leaves significant behavioral 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 a single, efficient sentence that front-loads the core action ('List all pending organisation invitations') and appends relevant output details. There is no wasted text, and it directly communicates essential information 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?

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It covers what the tool does and what data it returns, but lacks context on permissions, pagination, or error handling. Without annotations or output schema, more behavioral detail would improve completeness for a list operation.

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 adds no parameter details, focusing instead on the tool's purpose and output attributes. This meets the baseline for zero-parameter tools.

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 verb ('List') and resource ('pending organisation invitations') with specific attributes enumerated (email, name, role, sent date, expiry). It distinguishes from siblings like 'cloudforge_list_members' by focusing on pending invitations rather than current members. However, it doesn't explicitly contrast with 'cloudforge_invite_member' for creation vs. listing.

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 usage context by specifying 'pending' invitations, suggesting this tool is for reviewing outstanding invites rather than active members or historical data. However, it lacks explicit guidance on when to use this versus 'cloudforge_list_members' or 'cloudforge_cancel_invitation', and doesn't mention prerequisites like authentication or access rights.

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 returns specific fields (name, email, role, status), which adds useful context beyond the input schema. However, it does not mention behavioral aspects like pagination, rate limits, authentication needs, or error handling, leaving gaps for a tool with no 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, efficient sentence that front-loads the core functionality ('List all members') and includes essential details about scope and return values. There is no wasted text, making it highly concise 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 simplicity (0 parameters, no output schema, no annotations), the description is reasonably complete. It explains what the tool does and what it returns. However, it could be more comprehensive by addressing potential behavioral aspects like data freshness or access permissions, which are relevant for a list operation with no annotation support.

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 does not discuss parameters, focusing instead on the tool's purpose and output. This meets the baseline for tools with no parameters, as it adds value without redundancy.

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 verb ('List') and resource ('all members of the current user's CloudForge organisation'), specifying exactly what the tool does. It distinguishes itself from sibling tools like cloudforge_list_diagrams and cloudforge_list_invitations by focusing on organisation members rather than diagrams or invitations.

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 usage context by specifying 'current user's CloudForge organisation,' suggesting it's for viewing members within the user's own organisation. However, it lacks explicit guidance on when to use this tool versus alternatives like cloudforge_list_invitations or cloudforge_remove_member, and does not mention any prerequisites or 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 performs a conversion without server fetching, which is useful behavioral context. However, it lacks details on error handling, output format (e.g., Mermaid syntax specifics), or performance aspects like rate limits or data size constraints.

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 and adds usage guidance in the second, with zero wasted words. Every sentence earns its place by providing essential information efficiently.

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 (conversion task), no annotations, and no output schema, the description is adequate but incomplete. It covers purpose and usage well but lacks details on behavioral traits (e.g., error cases) and output specifics, which would be helpful for an agent to use 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%, so the schema already documents the 'diagram_json' parameter fully. The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints on JSON structure, 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 ('Convert raw diagram JSON to a Mermaid flowchart') and resource ('nodes + edges'), distinguishing it from siblings like 'cloudforge_diagram_to_mermaid' by specifying 'without fetching from the server' and 'when you already have diagram data in memory.'

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

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

It explicitly states when to use this tool ('when you already have diagram data in memory') and implies when not to use it (vs. fetching from server), with a clear alternative context compared to sibling tools like 'cloudforge_get_diagram' or 'cloudforge_diagram_to_mermaid' that might involve server interaction.

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 mentions the tool is 'faster' (a performance trait) but doesn't disclose other behavioral aspects like authentication needs, rate limits, or what 'recently' means. The description adds some value but lacks comprehensive behavioral context.

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, efficient sentence that front-loads the purpose and includes a key usage guideline, with no wasted words.

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

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

Given no annotations, no output schema, and a simple tool with 0 parameters, the description is adequate but has gaps: it doesn't explain what 'recently' means or describe the return format. It meets minimum viability but could be more complete.

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 doesn't add parameter details, but with no parameters, a baseline of 4 is appropriate as it doesn't need to compensate for gaps.

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

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

The description clearly states the specific action ('Get recently accessed/modified diagrams') and distinguishes it from a sibling tool ('faster lookup than list_diagrams'), providing both verb+resource and differentiation.

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

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

It explicitly states when to use this tool ('faster lookup than list_diagrams'), providing clear guidance on choosing this over an alternative sibling tool.

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

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

With no annotations provided, the description carries the full burden. It discloses the Owner restriction (important behavioral constraint) and the ID source requirement, but doesn't mention permission requirements, whether the action is reversible, confirmation prompts, or what happens to the member's resources. For a destructive operation with zero annotation coverage, this leaves significant behavioral 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?

Two tightly focused sentences with zero waste: the first states the core action and key restriction, the second provides essential implementation guidance. Every word earns its place, and the most critical information (what it does and the Owner restriction) is front-loaded.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic action and a key restriction, but lacks information about permissions, reversibility, confirmation requirements, and expected response format. Given the tool's potential impact, more behavioral context would be beneficial.

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% (the single parameter has a clear description), so the baseline is 3. The description adds value by specifying the exact source for obtaining the parameter value ('from cloudforge_list_members'), which provides practical implementation guidance beyond the schema's type/format documentation.

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 ('Remove a member') and target resource ('from the organisation'), distinguishing it from siblings like cloudforge_list_members (which lists members) and cloudforge_invite_member (which adds members). It provides a complete verb+resource+scope statement.

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 about when NOT to use it ('Cannot remove the Owner') and references a sibling tool for obtaining required data ('Pass the member's user ID from cloudforge_list_members'). However, it doesn't explicitly mention alternatives like cloudforge_cancel_invitation for pending invitations or specify prerequisites beyond the ID source.

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 mentions 'Save or update' which implies mutation, but fails to specify whether this creates new diagrams or overwrites existing ones, what permissions are required, or if there are rate limits. The description is too vague for a mutation 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, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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 mutation tool with 5 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what happens on success or failure, whether the operation is idempotent, or how to handle errors. Given the complexity and lack of structured data, more context is needed for the agent to use this tool effectively.

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, clearly documenting all 5 parameters including their types, enums, and purposes. The description adds no additional parameter semantics beyond what's already in the schema, so it meets the baseline score of 3 without compensating for any gaps.

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

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

The description clearly states the action ('Save or update') and resource ('a diagram in CloudForge'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'cloudforge_get_diagram' or 'cloudforge_delete_diagram' in terms of specific use cases, which prevents 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 no guidance on when to use this tool versus alternatives like 'cloudforge_get_diagram' for retrieval or 'cloudforge_delete_diagram' for removal. It also lacks context on prerequisites, such as whether authentication is needed or if there are limitations on diagram size or format.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool 'Returns resource IDs, labels, categories, and suggested connections,' which adds some context about output format. However, it lacks details on permissions, rate limits, or whether this is a read-only operation, which is important for a tool that might involve AI processing.

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

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

The description is a single, well-structured sentence that efficiently conveys the core purpose and output. It avoids redundancy and is front-loaded with the main action, making it easy for an agent to parse quickly.

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 (AI recommendations with 2 parameters) and lack of annotations and output schema, the description is moderately complete. It covers the purpose and output format but misses behavioral aspects like safety or performance. It's adequate as a starting point but could be enhanced with more context for better agent 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 schema description coverage is 100%, with clear descriptions for both parameters (e.g., 'What you want to build' for 'description' and 'Target cloud provider' for 'provider'). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for adequate coverage without extra value.

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 AI-recommended cloud resources for a described use case.' It specifies the action (get recommendations) and the resource (cloud resources), though it doesn't explicitly differentiate from sibling tools like cloudforge_architecture_summary or cloudforge_generate_terraform, which might also involve cloud resource recommendations or 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 no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, exclusions, or compare it to sibling tools such as cloudforge_architecture_summary or cloudforge_generate_terraform, leaving the agent to infer usage context solely from the purpose.

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