website-search

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

Beyond the readOnly/idempotent annotations, the description discloses important behavioral traits: the response always includes an inScopeCheck, the server never requests program docs or roadmap (with instructions to keep them local), and data flows to the AI for local analysis. These details provide significant transparency about privacy and processing behavior that annotations do not cover.

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

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

The description is a single dense paragraph with five sentences, each serving a purpose: content list, response guarantee, scope exclusion, pairing suggestion, and privacy behavior. It is longer than ideal but contains no fluff; however, the 'Pairs naturally' and 'This server never requests' sentences could be considered slightly tangential to tool invocation. Still, it remains efficient for the amount of context provided.

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

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

The tool has no output schema, so the description compensates by thoroughly listing the response components: coverage taxonomy, differentiation guidance, disambiguation block, worked examples, out-of-scope examples, and inScopeCheck. It also explains the optional framework behavior and the effect of include_framework_alignment (slim response) and whitespace via schema. For a read-only query tool with rich schema descriptions, this is 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no direct parameter-level detail beyond what the schema already provides, but the schema itself has rich descriptions for each parameter (framework, whitespace, include_process_shaped, include_framework_alignment). Since schema carries the full semantic burden, a 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 identifies the tool as 'Get the AI Defense Matrix cross-mapping playbook' with a specific purpose of mapping product capabilities to matrix cells. It enumerates the content delivered (coverage taxonomy, differentiation guidance, disambiguation, examples), distinguishing it from sibling tools like aidefense_get_matrix and aidefense_get_framework_alignment. The scope exclusion for products that use AI to solve non-AI security problems further clarifies its niche.

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

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

The description provides context on when this tool is relevant, such as pairing with product_load_context for positioning work, and explicitly states that products using AI for non-AI security problems belong in the Cyber Defense Matrix rather than this tool. However, it lacks an explicit 'use when X, use Y instead' structure and does not name an alternative tool for the Cyber Defense Matrix, making the guidance useful but not fully precise.

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

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

Annotations already mark the operation as read-only, idempotent, and non-destructive. The description goes further by disclosing that the AI applies prompts locally, no program details leave the client, the server never requests program docs or roadmap, and gate mode returns only the deployment-gate workflow plus gate-tier prompts. This is valuable behavioral context beyond 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 moderately sized but each sentence earns its place: core purpose first, then mode/pattern options, then privacy/processing details. No redundant phrasing or filler; the structure is logical and 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?

Despite no output schema, the description tells the caller what to expect: per-cell prompts, gap-inventory template, workflow, and gate-mode variant. It covers the full range of use cases and important constraints (local processing, no data exfiltration). For a tool with six optional parameters, this is well-rounded and 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?

Schema coverage is 100%, so baseline is 3. The description adds some meaning for mode='gate' (binary deployment-gate returns gate workflow plus prompts only) and consumer pattern scoping. However, it refers to 'consumerPattern' instead of the schema's 'consumer_pattern', which is a naming inconsistency that could confuse an agent. Since the schema already documents parameters fully, the description neither significantly adds nor detracts, except for this mismatch.

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

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

The description opens with a specific verb and resource: 'Get the AI Defense Matrix evaluation playbook' for assessing an AI security program. It lists concrete contents (per-cell prompts, gap-inventory template, workflow) and distinct behavior for mode='gate'. This clearly distinguishes it from sibling tools like 'aidefense_get_matrix' and domain-specific template services.

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

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

The description gives clear context for when to use the tool (assessing an AI security program, binary deployment-gate decisions via mode='gate', scoping via consumer_pattern). It does not explicitly name alternative tools or state 'when not to use', but the specificity of the use case is strong enough for an agent to make a selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable context beyond that: it explains the output structure (rows and 'concepts' array) and discloses a privacy-relevant behavior ('never requests your program docs... keeps them local'). This is meaningful extra transparency without contradicting 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 five sentences, but each is informative: main purpose, output structure, concepts array, buyer shortcut, and privacy note. It is slightly long but earns its length given the tool's complexity, and the most critical information 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 complex tool with no output schema, the description covers the essentials: nine framework names, row semantics, concepts array, buyer scoping, and usage context. It omits any mention of pagination or response envelope, but those are likely minimal and the safety profile is well-covered by annotations.

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

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

Schema coverage is 100%: both 'buyer' and 'framework' are fully documented with enums and descriptions. The tool description only repeats the buyer shortcut and precedence rule, adding no new semantic value over the schema, so the baseline score of 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 states a specific verb and resource: 'Get AI Defense Matrix cross-mappings to nine external frameworks' and enumerates all nine. It clearly differentiates from siblings by focusing on cross-mappings rather than the matrix itself, making the purpose unmistakable.

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

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

It explicitly says 'Use to translate between framework vocabularies,' providing a clear when-to-use context. It also mentions the buyer archetype shortcut for scoping, but does not contrast with alternative tools like aidefense_cross_map, so no explicit exclusion is given.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds valuable behavioral context: it never requests program docs or product roadmap, instructs the AI to keep them local, and describes the data flow (matrix, alignments, playbooks) to the AI. This exceeds the structured 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?

Two sentences, with the first sentence front-loaded with core purpose and structure. The second sentence adds privacy/flow context that earns its place for transparency, though it slightly extends beyond immediate tool-selection needs.

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 retrieval tool with only optional parameters and no output schema, the description covers matrix content, filtering capabilities, and privacy behavior. It does not detail the exact JSON return shape, but the parameter schema and annotations fill in the remaining gaps adequately.

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 each parameter having an enum and description. The description's mention of 'optional filtering by asset or function' merely echoes the schema and adds no new semantic detail, so a baseline score 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 it retrieves the 'structured AI Defense Matrix' with specific dimensions (8 asset rows x 6 NIST CSF 2.0 function columns) and describes cell content. This distinguishes it from sibling tools like cross_map or framework_alignment, using a specific verb and resource.

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

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

No explicit guidance on when to use this tool versus alternatives such as aidefense_cross_map or get_framework_alignment. It implies usage for obtaining the matrix and mentions filtering, but does not state exclusions or alternative scenarios, leaving the agent to infer.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: it explicitly states the server "never requests your program docs or product roadmap" and "instructs your AI to keep them local," disclosing a privacy posture. It also clarifies that the context flows to the AI for local analysis, which is not implied by the 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 a single dense sentence, but it is front-loaded with the core action and resource. The enumeration of nine frameworks is verbose yet informative, and the privacy note adds distinct value. No redundant or filler content is present, though splitting into two sentences would improve readability. Overall, every clause contributes.

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 output schema, the description does a good job explaining what the tool loads and why it is useful. It lists the matrix, frameworks, and playbooks, and addresses data privacy. However, it does not describe any return value or side-effect (though for a load_context tool, the primary effect is context injection, which is implied). The description is sufficiently complete for an agent to understand the tool's scope and content.

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%: both parameters (purpose and detail_level) have clear descriptions with enums. The description mentions "evaluation + cross-mapping playbooks," which aligns with the purpose parameter's enum values, but it does not add any syntax, defaults, or nuances beyond what the schema already provides. Thus the baseline of 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 opens with a clear verb and resource: "Load Lenny Zeltser's AI Defense Matrix context," and then enumerates the exact contents (8-asset x 6-NIST-CSF-2.0-function matrix, nine cross-walked frameworks, playbooks). This distinguishes it from sibling load_context tools (e.g., cti_load_context, ir_load_context) by naming a specific, unique knowledge domain.

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 explicit guidance on when to use this tool versus alternatives. It does not mention sibling tools like aidefense_get_matrix or aidefense_evaluate_program, nor does it state prerequisites or contrasting scenarios. The usage context is implied only by the tool's name and the listing of contents, which is insufficient for clear decision-making.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, but the description adds substantial behavioral detail: it returns the framework, asset rows, cells, and prompts, and explains the privacy model ('never requests your program docs... keeps them local'). This gives the agent clear insight into what happens during invocation.

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?

Though moderately long, every sentence serves a purpose: main action, return values, use case, limitation + alternative, privacy note. The description is front-loaded with the purpose, and structure is logical and scannable.

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

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

There is no output schema, so the description fully covers return values (framework, asset rows, cells, prompts). It also explains which inputs are supported, when to use an alternative, and the privacy behavior, making it complete for this simple 1-parameter lookup 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?

Schema description coverage is 100%, with the concept parameter already documented with patterns and length constraints. The description adds examples and case-insensitivity, but these largely mirror the schema. Baseline of 3 is appropriate because 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 opens with a specific verb and resource: 'Reverse-lookup a single concept ID... across the AI Defense Matrix.' It clearly lists example IDs and return elements, and explicitly distinguishes itself from the sibling tool aidefense_get_framework_alignment for prose-only frameworks. This provides a fully clear and 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 gives explicit use case ('Useful when a vendor's product is defined by a specific technique...') and states a direct alternative: 'for prose-only frameworks... use aidefense_get_framework_alignment instead.' It also sets a boundary on what inputs it accepts, preventing misuse with unsupported framework IDs.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds substantive behavioral context about data handling: the server never requests assessment notes or report and instructs the AI to keep them local. This goes beyond annotations and is particularly relevant for privacy, with no contradictions.

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

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

Three concise sentences, each serving a distinct purpose: what the tool does, how it differs from the alternative, and its privacy behavior. The primary action verb is front-loaded and there is no redundant or filler text.

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 (no parameters, read-only, strong annotations) and no output schema, the description covers all necessary aspects: purpose, usage alternative, and data handling. There are no significant gaps for a caller to safely invoke the 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?

The tool has zero parameters, so schema coverage is 100% vacuously. The description doesn't need to explain parameter details; the baseline for a zero-parameter tool is 4, and there's no missing parameter information to compensate for.

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 its function: retrieving Lenny Zeltser's Security Assessment one-page executive brief template. It also differentiates from the sibling assessment_get_template by specifying it's the standalone brief-only variant, which prevents confusion.

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 names the alternative tool (assessment_get_template) and defines when to use this one: for callers that only want the brief without the long-form report. This gives clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by stating 'This server never requests your assessment notes or report and instructs your AI to keep them local', which goes beyond the annotations and clarifies privacy 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 concise (3 sentences) and front-loaded with the primary purpose. Each sentence adds value: the first defines what the tool does, the second clarifies the relationship to assessment_load_context, and the third discloses a key privacy behavior. No fluff or 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 0-parameter, read-only tool with no output schema, the description provides sufficient context: it names the target domain (Security Assessment), explains the use case (fallback routing), and gives a privacy guarantee. Sibling tool names further clarify the domain-specific nature. The description fully covers what the tool returns and when to use it.

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

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

The tool has 0 parameters, so baseline is 4. The description doesn't need to explain parameter semantics, and the schema is empty, providing no ambiguity. The description itself doesn't mention parameters, but that's fine given the absence of params.

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 Lenny Zeltser's Security Assessment cross-server handoff routes' with the specific resource being 'Security Assessment' and the function being 'cross-server handoff routes'. It also explains that it surfaces a compact subset of assessment_load_context, distinguishing it from the full context tool and sibling cross-server route tools for other domains.

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 this MCP server can't fulfill a request'. It also implies an alternative by noting it is a compact subset of assessment_load_context, suggesting the full context tool for comprehensive needs. However, it doesn't explicitly name alternatives or provide when-not-to-use guidance beyond that implication.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context: the server 'never requests your assessment notes or report' and keeps data local, plus it clarifies the meaning of sibling blocks. This goes beyond the annotations without contradicting them.

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 long, front-loads the core purpose, and each sentence serves a distinct function: purpose and parameter behavior/privacy. 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?

For a simple read-only tool with one optional parameter, the description fully covers what the agent needs: what it returns (frameworks plus siblings), how to control siblings, and a key privacy behavioral note. No output schema is present, but the return is self-evident from the purpose.

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 covers 100% of the single parameter (include_siblings) with a clear description. The description adds the instruction to pass 'include_siblings: false' to skip blocks, which slightly reinforces but does not significantly extend the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves 'Lenny Zeltser's Security Assessment frameworks' and distinguishes between primary and sibling frames, which differentiates it from the many other get_frameworks tools (cti, ir, malware, vuln). The verb 'Get' plus the specific resource makes the purpose unambiguous.

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

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

The description provides context that the primary frameworks are 'the brief structurally derives from' and explains the optional sibling frames, giving some usage guidance. However, it does not explicitly contrast with alternative tools or state when to use this instead of others, so it falls short of a 5.

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

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

The description adds a significant behavioral guarantee beyond the annotations: the server never requests assessment notes or reports and instructs the AI to keep them local. This privacy/security disclosure is not captured in readOnlyHint or idempotentHint, providing valuable context for agents handling sensitive data. No contradiction with 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 concise and well-structured: a clear purpose statement, a topic list, a deferral note, and a behavioral guarantee. Every sentence adds value and the most important information is front-loaded. It avoids redundancy with the schema and annotations.

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 rich annotations and no output schema, the description provides complete guidance: it specifies the exact topics, notes the special handling for 'tone', and discloses the server's data-handling behavior. No significant gaps remain for an agent to effectively select and invoke this 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?

The schema already covers the single 'topic' parameter with an enum and a description of the default behavior. The tool description enriches semantics by explaining specific topics: 'severity' is described as 'the risk-adjusted severity model — the spine', and 'brief' as 'one-page brief section guidance'. It also clarifies that 'tone' is handled by another tool, adding meaning beyond the schema. Not every enum value is elaborated, but enough context is provided to aid selection.

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

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

The description clearly states the tool's function: retrieving Lenny Zeltser's expert security assessment report writing guidelines. It explicitly lists the covered topics, which differentiates it from sibling tools like cti_get_guidelines or ir_get_guidelines. The specific mention of deferring the 'tone' topic to get_security_writing_guidelines also distinguishes this tool from that alternative.

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

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

The description provides clear context for when to use the tool (for assessment report guidelines) and explicitly states an alternative for the 'tone' topic: use get_security_writing_guidelines instead. It does not explicitly compare with all sibling guidelines tools, but the deferral rule provides a concrete when-not scenario, earning a 4.

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

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

Annotations already indicate this is a safe, read-only, idempotent operation. The description adds meaningful behavioral context beyond annotations: it notes that the server never requests assessment notes or reports and instructs the AI to keep data local, which is important privacy guidance. No contradiction with 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 three sentences, front-loaded with the core purpose. It efficiently outlines the two output variants and adds a third sentence about privacy, which is relevant but somewhat tangential. No wasted words, though the privacy note could be seen as extra.

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

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

With no output schema, the description carries the burden of explaining the return value, which it does by listing the sections of the report and brief. It also addresses the tool's non-request for sensitive data, which is helpful context. It lacks specifics about format or how to use the template, but for a single-parameter template retrieval, it is sufficiently 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 schema provides full coverage for the 'kind' parameter with enum descriptions. The description enriches this by explaining the internal structure of both 'report' and 'brief', giving the agent a clearer sense of what each value returns. This goes beyond mere schema repetition.

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 retrieves Lenny Zeltser's security assessment template, distinguishing it from other domain-specific templates (CTI, IR) by name. It also differentiates between report and brief forms. However, it does not explicitly contrast with sibling tools like assessment_get_brief_template, which may overlap.

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 by detailing what the report and brief contain, helping an agent decide which artifact to request. It does not explicitly state when to use this tool over alternatives such as assessment_get_guidelines or other domain templates, nor does it mention 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, but the description adds significant behavioral context: the profile parameter annotates rather than filters, every section is returned for cross-profile comparisons, and the server never requests or retains the user's assessment notes. This privacy-local analysis disclosure goes well beyond structured 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 three sentences, dense but well-structured: purpose and payload, framework list, then key behavioral clarifications. The framework enumeration is lengthy but useful, and the privacy statement earns its place. Nothing is redundant with the schema.

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

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

No output schema exists, so the description carries the burden of explaining the return value, which it does thoroughly by listing the payload components. It also covers the key behavioral nuance (no filtering) and the data-handling guarantee, making it complete for a loading tool of this complexity.

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

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

Schema coverage is 100%, so each parameter already has a description. The description adds valuable context by explaining the payload structure and explicitly reinforcing that the profile parameter annotates rather than filters, with the rationale of enabling cross-profile comparisons. It also mentions the mcpHandoffs array, giving context for how parameters affect the response, even though this is not parameter-specific.

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 it loads Lenny Zeltser's security assessment report writing context for local analysis, enumerates the payload components, and distinguishes itself from sibling get_* tools by emphasizing full-context loading rather than filtered retrieval. The specific verb 'Load' and the resource scope make the purpose unambiguous.

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

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

It explicitly frames the tool as for local analysis and states the server never requests assessment notes, implying it is not for server-side review or scoring tools like assessment_review_report. It also explains the profile parameter's annotate-not-filter behavior, setting expectations for when to use this full-context loader. However, it does not explicitly name an alternative tool for narrower needs.

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

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

The description discloses a key behavioral trait beyond annotations: 'This server never requests your assessment notes or report and instructs your AI to keep them local—the templates and guidelines flow to your AI for local analysis.' This is not covered by readOnly/idempotent/destructive hints and adds important privacy/context. It also mentions providing a pointer to another tool. No contradiction with 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 main purpose and content details, and efficiently packs in the list of review items, groups, and the privacy note without fluff. Every sentence adds value.

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

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

Given the tool's nature (returning criteria/guidelines) and rich schema/annotations, the description sufficiently covers what the tool returns (17 items, five groups, cross-cutting criteria, severity model, anti-patterns), how it interacts with data (local analysis), and points to a related tool. No output schema exists, but the return content is adequately described.

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 provides 100% coverage with descriptions for both parameters (focus and sections), including enum values and explanations. The tool description does not add additional meaning about parameter usage beyond what the schema already states, so the baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get Lenny Zeltser's expert criteria for reviewing an existing security assessment report or brief.' It lists specific content (17 items, five groups, cross-cutting criteria, severity model, anti-patterns) and differentiates from sibling review tools by focusing on assessment reports. It also points to rating_score_writing as a separate tool, clarifying its scope.

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

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

The description implies when to use it: for reviewing an existing assessment report or brief, and mentions an alternative (rating_score_writing) for a numeric score. It also clarifies a privacy behavior (server never requests notes/report) which guides usage. However, it does not explicitly mention when not to use it or compare with all sibling review 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context beyond annotations: the server never requests the user's campaign or threat-intel notes and instructs the AI to keep them local, meaning templates flow to the AI for local analysis. This gives the agent a clear picture of the tool's privacy 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 three sentences, front-loaded with the primary purpose in the first sentence, and every subsequent sentence adds distinct value (differentiation and privacy behavior). There is no redundancy or filler.

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

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

For a zero-parameter, read-only template retrieval tool, the description is complete: it identifies the specific template, differentiates from the main variant, and explains privacy behavior. Even without an output schema, the description sufficiently communicates what the agent needs for selection and invocation.

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

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

The tool has zero parameters, so schema coverage is effectively 100% and there is nothing for the description to clarify. The baseline for a no-parameter tool is 4, and the description does not waste words on parameters, which is appropriate.

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

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

The description clearly states the tool's function: 'Get Lenny Zeltser's CTI one-page executive brief template.' It distinguishes from the sibling `cti_get_template` by explicitly labeling itself a 'standalone variant' for callers wanting only the brief without the long-form report, so there is no ambiguity about its scope.

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

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

The description explicitly names the alternative: 'Standalone variant of `cti_get_template` for callers that only want the brief without the long-form report.' This tells the agent exactly when to choose this tool over its primary sibling. It also adds a privacy guideline: the server never requests campaign or threat-intel notes and instructs the AI to keep them local, which informs usage in sensitive contexts.

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?

Beyond the read-only annotation, the description discloses important behavioral traits: it never requests campaign/threat-intel notes and instructs keeping data local, which is valuable context for an AI. It also positions itself as a compact subset, indicating data scope.

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 well-structured sentences with no redundancy. The primary purpose is front-loaded, and the additional privacy/behavioral detail earns its place without bloat.

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?

Despite having no output schema and no parameters, the description is complete for the tool's simplicity. It covers purpose, usage conditions, and critical behavioral transparency, making it fully self-contained for an AI to decide when and how to invoke it.

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 zero parameters, so the schema carries no burden. The description adds no parameter-specific details, but the baseline of 4 is appropriate given no parameters exist.

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

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

The description clearly states the tool's function: retrieving cross-server handoff routes for CTI when this server can't fulfill a request. It distinguishes itself from sibling tools by specifying it's CTI-specific and a compact subset of 'cti_load_context'.

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 defines when to use this tool: when the MCP server cannot fulfill a request, to find alternative servers or workflows. It also hints at using 'cti_load_context' for the full context, providing a clear alternative.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so description credit goes to extra context. The description adds a key behavioral trait: it never requests campaign/threat-intel notes and keeps templates/guidelines local for AI analysis, which is valuable operational transparency beyond 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?

Two sentences, front-loaded with the main purpose and then parameter usage plus a data-handling note. Every sentence earns its place with no fluff.

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

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

For a simple read-only retrieval tool with one optional param and no output schema, the description covers purpose, parameter, and data privacy. It doesn't detail response structure, but the input schema and description together sufficiently imply the content (primary frameworks + optional sibling blocks).

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 covers 100% of the parameter with clear meaning and default. The description reinforces this by showing how to skip sibling blocks, adding slight clarification. However, it doesn't add substantial new semantics beyond the schema.

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

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

The description clearly states the tool's function: retrieving Lenny Zeltser's CTI frameworks and optional sibling frames. It specifies the resource (CTI frameworks) and distinguishes primary vs sibling, making it distinct from sibling tools like ir_get_frameworks or cti_get_guidelines.

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

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

The description explains the optional parameter behavior ('Pass include_siblings: false to skip sibling blocks') but does not explicitly compare this tool to alternatives or state when not to use it. Usage is implied by the name and context, but no exclusions are given.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses a privacy stance: 'This server never requests your campaign or threat-intel notes and instructs your AI to keep them local.' It also explains content-scoping behavior (some topics defer to another tool), which is useful 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 long but front-loaded with the core purpose. The enumeration of topics is dense and could be structured with bullets, but every sentence carries useful information. The privacy note is a slight tangent but valuable.

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 17 enum topics, 2 parameters, and no output schema, the description is remarkably complete. It covers all topic meanings, the deferral behavior, parameter pairing, and a privacy guarantee. This fully equips an agent to select and invoke the tool 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 coverage is 100%, but the description adds significant meaning to the enum values (e.g., 'attribution (full Six Signals prose)', 'confidence (ICD-203 ladder)', 'pyramid_of_pain') and clarifies the relationship between topic and field_id. It also states that 'field_id' is 'Only meaningful with topic='fields'', reinforcing the schema.

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

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

The description clearly states 'Get Lenny Zeltser's expert CTI writing guidelines' with a specific verb and resource. It distinguishes itself from siblings by explicitly deferring general writing topics to `get_security_writing_guidelines` and enumerating CTI-specific topics.

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

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

The description gives explicit guidance on when to use this tool vs the alternative: 'The general writing topics ... now defer to `get_security_writing_guidelines` for the canonical Five Elements rules; CTI-specific content lives in the other topics.' It also instructs pairing 'fields' with field_id, and notes default behavior when topic omitted.

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

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

Annotations already declare read-only and non-destructive behavior, which the description does not contradict. It adds valuable context about privacy (never requesting campaign/note content and keeping it local) and details the template contents, enriching transparency beyond the structured 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 moderately long but well-structured: it starts with the tool's purpose, then breaks down the report and brief contents, and ends with a privacy note. Each sentence provides useful information, though the section lists could have been 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 simple template-fetching tool, the description is fairly complete. It explains the two template types with their sections and includes a privacy behavior note. With no output schema, it could have mentioned the return format, but the content details largely compensate.

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

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

The schema provides full coverage of the 'template' parameter with an enum and description. The tool description adds meaning by elaborating on what each enum value ('report' or 'brief') contains, listing the sections covered, which helps the agent choose correctly.

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 gets Lenny Zeltser's cyber threat intel template, with a specific verb and resource. It distinguishes from siblings by naming the author and domain, and details the two template variants (report and brief), making it unambiguous.

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

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

The description explains the difference between the report and brief templates, providing clear context on what each offers. However, it does not explicitly state when to use this tool over the many sibling template tools (e.g., cti_get_brief_template) or other domain templates, so guidance is implicit rather than explicit.

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

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

Beyond the readOnly/idempotent annotations, the description discloses important behavioral details: the profile parameter annotates rather than filters, all sections are returned for cross-profile comparisons, and the server does not request sensitive notes. This adds significant transparency about the tool's operation and data 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 four sentences, front-loaded with the main purpose, then lists payload components, clarifies a key parameter behavior, and explains privacy. Every sentence adds value, though the sentence about payload contents is a bit dense.

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, the description covers purpose, payload contents, parameter nuance, and privacy, despite no output schema. It provides enough information for an agent to understand what to expect and how to use the 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?

Schema description coverage is 100%, so baseline is 3. The description reiterates the profile parameter's annotate-not-filter behavior, which the schema already documents, and adds no new syntax or format details for other parameters. It does not compensate beyond the schema.

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

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

The description clearly states a specific action ('Load Lenny Zeltser's CTI writing context for local analysis') and enumerates the payload contents (section guidance, completeness criteria, frameworks, attribution signals, etc.). It distinguishes itself from sibling get_* tools by emphasizing comprehensive context loading and local analysis.

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 provides clear context for when to use the tool—when local analysis is needed and privacy matters ('never requests your campaign or threat-intel notes'). However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

In addition to the readOnly and idempotent annotations, the description discloses a meaningful behavioral trait: 'This server never requests your campaign or threat-intel notes and instructs your AI to keep them local—templates and guidelines flow to your AI for local analysis.' This adds privacy/context beyond what annotations already convey and clarifies the tool's non-collector nature.

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

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

The description is two sentences, with the primary purpose front-loaded in the first sentence and the privacy behavior succinctly stated in the second. Every clause earns its place with no redundancy or filler.

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

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

The tool is simple (2 optional params, no output schema), and the description covers the main deliverables (per-theme criteria, cross-cutting criteria, anti-patterns, focus-driven analysis) plus privacy behavior. It lacks an explicit note on return format, but given the simplicity and annotations, this is adequate without being 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?

The input schema already provides complete descriptions for both 'focus' and 'sections' parameters with 100% coverage. The description's mention of 'focus-driven writing analysis' adds minimal extra meaning, so it aligns with the baseline of 3 for well-documented schemas.

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

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

The description opens with a specific action and resource: 'Get Lenny Zeltser's expert criteria for reviewing an existing CTI report or brief.' It clearly distinguishes this CTI-specific tool from sibling report-review tools (e.g., assessment_review_report, ir_review_report) by emphasizing the CTI domain and named expert.

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

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

The description implies the tool is for use when reviewing existing CTI reports and provides the behavioral note that it never requests campaign notes, guiding the agent on safe usage. However, it does not explicitly name alternatives or exclusion criteria relative to sibling tools, so it stops short of full guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds value by disclosing what is returned (title, date, topics, summary, and full body text), which goes beyond the annotations. It does not mention any request behavior, but with annotations covering safety, this additional return-value context earns a high 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 two sentences, front-loaded with the core purpose, then adding context and return fields. Every sentence earns its place, with no redundancy or fluff.

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

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

With one parameter, high schema coverage, and annotations covering safety, the description is sufficiently complete. It states the input (URL path), the output fields, and the topical domain. An output schema exists, so return structure is likely documented there, and the description adds the necessary human-oriented 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 coverage is 100%, and the parameter description already explains that 'url' is an article URL path. The description repeats 'by URL path' but does not add new formatting or syntax details. Baseline 3 applies because 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 gets the full content of a specific article from Lenny Zeltser's Website by URL path. It uses a specific verb ('Get'), names the resource ('full content of a specific article'), and differentiates from sibling tools like search_zeltser by emphasizing the URL path access method.

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 conveys context: use this when you have a specific article URL path and need its full content. It does not explicitly mention alternatives or exclusions, but the context is clear enough to distinguish from search tools. A slight gap is the lack of explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the server scope and example contents but does not describe output format or pagination. That's acceptable for a read-only listing tool, but it adds limited behavioral nuance beyond the 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?

One concise sentence, front-loaded with the verb 'List', no redundancy. It earns its place.

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

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

As a simple no-parameter discovery tool, the description is nearly complete. It could explicitly state that the output is a list of available capabilities/tools, but the purpose is clearly implied. Given the absence of an output schema, a brief mention of the return type would make it fully 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 tool takes zero parameters, and the schema is empty with 100% coverage. Per rubric, the baseline for 0 params is 4, and the description correctly implies no arguments are needed.

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

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

The description uses the specific verb 'List' and names the resource ('all capabilities and tools available from the Lenny Zeltser's Website MCP server'), clearly distinguishing this meta-discovery tool from the many sibling tools that perform specific functions. It also gives concrete examples (search tools, IR report writing assistance) to clarify scope.

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

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

The description implies the tool is for discovering what's available on the server, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions. Given the large number of sibling tools, it would be helpful to say 'use this to discover available tools before invoking others,' but that's only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds value by listing the exact statistics returned (total pages indexed, last update time, available tools), which is useful behavioral context beyond the annotations. No additional safety or side-effect disclosure is needed.

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 succinct sentence that front-loads the verb ('Get') and resource ('statistics'). Every word contributes to clarity, with no redundant or filler content. It is appropriately sized for a simple read-only 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 simplicity (no params), strong annotations (read-only, idempotent), and the presence of an output schema, the description is complete. It states what the tool returns, and the output schema likely details the structure. No additional context 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?

The tool has 0 parameters, so the baseline is 4 per instructions. The description does not need to explain parameter semantics, and the schema is empty. The description adds no parameter details, but none are 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 tool's function: 'Get statistics about the Lenny Zeltser's Website search index' and enumerates specific returned items (total pages indexed, last update time, available tools). This distinguishes it from sibling tools like get_article or get_capabilities, which address different resources or purposes.

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 the exact information it provides (index statistics). Although it does not explicitly mention alternatives or exclusions, the purpose is clear enough for an agent to select it when index statistics are needed, and no sibling tool covers the same function. However, it lacks explicit 'use this instead of X' guidance, preventing a 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description adds valuable behavioral context: 'This server never requests your documents and instructs your AI to keep them local—guidelines flow to your AI for local analysis.' This privacy-related behavior is not captured by annotations and is critical for user trust.

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 purpose and includes only sentences that add unique information: scope, rating-sheet specifics, privacy guarantee, and an alternative-tool note. No filler or redundancy. Despite length, every sentence earns its place.

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

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

Given the tool's moderate complexity, the description covers output expectations (guidelines and rating-sheet items), domain applicability, privacy behavior, and alternative tools. The input schema and annotations handle parameter and safety details, so nothing important is left unexplained.

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 focus enum and include_examples default. The description adds some mapping by listing aspects like tone, structure, clarity, and executive summaries, but it does not significantly enrich understanding of the two parameters beyond what the schema provides. 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 opens with a specific verb and resource: 'Get Lenny Zeltser's expert writing guidelines for security reports and assessments.' It clearly enumerates the covered aspects (tone, structure, clarity, executive summaries, mistakes) and distinguishes itself from incident-response guideline tools by stating 'Works for any security document' and referencing the ir_* 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?

Explicitly provides usage context: 'Works for any security document' and gives an alternative for a specific case: 'For incident response reports specifically, use the ir_* tools which provide deeper section-by-section review criteria.' Also gives a practical tip for adjusting output size via the include_examples parameter.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds meaningful behavioral context beyond annotations by disclosing that the server 'never requests your incident notes' and instructs the AI to keep them local, which is crucial for privacy-conscious callers. No contradiction exists.

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

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

The description is concise (two sentences), front-loaded with the main purpose, then the variant distinction, then the privacy note. Every sentence adds value without redundancy or filler.

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

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

For a simple no-parameter getter, the description is complete: it identifies the resource, differentiates from the long-form template, and explains the privacy behavior. Given the rich annotations and empty schema, no additional context is necessary.

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

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

The tool has zero parameters, so the description need not explain parameter meanings. The schema coverage is 100% (empty properties), and the description adds no param details because none are needed. Baseline for 0 params is 4, and no extra info 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 tool gets 'Lenny Zeltser's IR one-page executive brief template', identifying the exact resource and purpose. It also distinguishes itself from the sibling `ir_get_template` by noting it's the 'Standalone variant' for callers wanting only the brief, not the long-form report.

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 names the alternative tool `ir_get_template` and explains when to use this variant ('for callers that only want the brief without the long-form report'). It also provides a privacy guideline: 'This server never requests your incident notes and instructs your AI to keep them local', which helps agents decide when to use this tool versus others.

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?

Beyond the annotations (read-only, idempotent), the description discloses a critical privacy behavior: 'This server never requests your incident notes and instructs your AI to keep them local—guidelines flow to your AI for local analysis.' It also clarifies the output is a compact subset of ir_load_context, adding operational understanding not present in 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 purpose and immediately followed by crucial behavioral context. Every clause earns its place with no redundancy or filler.

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

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

For a zero-parameter routing tool with strong annotations, the description covers the intent, the usage scenario, its relation to ir_load_context, and privacy guidelines. This is fully adequate for an agent to decide when and how to invoke the 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?

The tool has zero parameters, so per the rubric the baseline is 4. The description adds no parameter-specific details, which is appropriate since there are none to explain.

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

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

The description explicitly states the tool retrieves 'Lenny Zeltser's IR cross-server handoff routes' and defines the use case ('when this MCP server can't fulfill a request'). It also distinguishes itself from ir_load_context by noting it surfaces a 'compact subset', making the purpose unmistakable.

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

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

The description gives a clear when-to-use trigger ('when this MCP server can't fulfill a request') and mentions ir_load_context as a related broader tool, implying an alternative. However, it stops short of an explicit 'when not to use' or direct pointer to alternatives beyond the subset mention.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context by stating that the server never requests incident notes and instructs the AI to keep them local, which is a meaningful privacy guarantee not present in 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 main purpose and parameter behavior, then a privacy note. Every sentence adds distinct value, and there is no redundant explanation or fluff.

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—one optional parameter, no output schema, and explicit read-only/idempotent annotations—the description covers all key aspects: what is retrieved, the optional sibling blocks, how to skip them, and the privacy behavior. This is sufficient for an AI to invoke 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?

The sole parameter include_siblings is fully documented in the schema with a detailed description of the siblingFrames and siblingArtifacts blocks. The tool description adds a brief usage example ('Pass include_siblings: false') but does not significantly enhance the schema's already thorough documentation; hence baseline 3.

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

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

The description clearly states the tool retrieves Lenny Zeltser's IR frameworks, using the verb 'Get' and naming the specific resource. It also distinguishes between primary frameworks and optional sibling frames, setting it apart from sibling framework tools for other domains (e.g., cti_get_frameworks). This provides unambiguous 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 a clear context: it's for IR frameworks that the brief structurally derives from, implying usage in incident response brief generation. It gives a direct parameter usage instruction ('Pass include_siblings: false to skip sibling blocks') but does not explicitly name alternative tools or state when not to use this tool, so it lacks explicit 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context: it 'never requests your incident notes' and instructs the AI to keep them local, plus conditional output details about the rating-sheet checklist appendix. No contradiction with 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 three sentences: purpose, topic enumeration, and privacy note. The topic list is dense but necessary; the privacy sentence is an extra but valuable addition. No fluff, though the long enum list makes it slightly less scannable.

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

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

The tool is simple (1 optional param, no output schema). The description covers purpose, topics, conditional behavior, and privacy. It doesn't describe the general response format beyond the checklist appendix, but for this tool that's a minor gap.

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 covers 100% of the parameter with a descriptive enum. The description enriches this by providing one-line semantic hints for each topic (e.g., 'tone (collaborative framing)') and the instruction to omit for full guidelines, adding value beyond the schema.

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

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

The description opens with a specific verb and resource: 'Get Lenny Zeltser's expert writing guidelines for incident response reports.' It enumerates ten distinct topics, which clearly distinguishes it from sibling tools like ir_get_frameworks or cti_get_guidelines.

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

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

The description clearly establishes the tool's domain (incident response reports) and lists all covered topics, signaling when to use it. It also notes that 'handoffs' routes to other servers, implying an alternative. However, it doesn't explicitly state when to prefer sibling tools like ir_get_frameworks for framework-specific queries.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds behavioral context beyond annotations: it states the server 'never requests your incident notes' and 'instructs your AI to keep them local', plus a version note ('IR 1.5.0+') for the brief variant. This enriches transparency without contradicting 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 concise, with only three sentences. The first sentence states the core purpose, the second explains parameter usage, and the third provides a privacy guarantee. No redundant or filler content. Front-loaded and effective.

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

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

The tool is simple (one optional enum parameter, read-only, no output schema), and the description adequately covers its purpose, parameter choices, and behavioral nuances. The privacy note is especially valuable given the sensitive IR context. Nothing critical is missing, making the description complete for an agent.

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

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

The schema already describes the 'kind' parameter with full enum coverage (100%). The description adds meaning by specifying the default value ('report — default for backward compatibility') and version availability ('IR 1.5.0+'), which are not present in the schema. This extra context justifies a score above the baseline 3.

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

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

The description clearly states the tool's purpose: 'Get Lenny Zeltser's structured incident response template' with specific scope ('Covers all critical IR sections with field-by-field guidance'). The verb 'Get' and the specific resource distinguish it from sibling tools like ir_get_brief_template or cti_get_template, establishing clear identity.

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 on how to use the tool, especially the 'kind' parameter with 'report' default and 'brief' option. It also explains the server's privacy behavior (never requests notes, keeps them local). However, it does not explicitly mention when not to use this tool or name alternatives, so it falls short of full exclusion guidance.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context: it guarantees privacy ('This server never requests your incident notes and instructs your AI to keep them local') and documents response size behavior for each detail_level. No contradictions with 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 four sentences, each carrying distinct information: purpose/contents, rating-sheet reference, privacy guarantee, and parameter control. It is front-loaded with the core function and avoids filler.

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

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

Given the tool has no output schema and four parameters, the description adequately covers return contents, response sizing, privacy behavior, and parameter interactions. It tells the agent what to expect (guidelines and rating-sheet items) and how to tailor the response, making it sufficient for tool selection and invocation.

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

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

Schema descriptions already cover all four parameters (topics, detail_level, incident_type, include_examples), so baseline is 3. The description adds value by explaining that topics overrides detail_level for fine-grained control, that incident_type saves tokens, and by providing token estimates for detail_level options. This gives agents a deeper understanding of how to combine parameters effectively.

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

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

The description opens with a specific verb ('Load') and names the exact resource ('Lenny Zeltser's IR report writing context'), then enumerates what it returns (expert guidelines for field completeness, incident identification, notification triggers, and writing quality). This clearly distinguishes it from sibling load_context tools for other domains, though it doesn't explicitly differentiate from ir_get_guidelines.

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

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

The description provides clear usage context: 'for local analysis' and 'as concrete reference points for grounded feedback.' It also gives guidance on controlling response size via detail_level and explains the privacy guarantee. However, it does not explicitly state when to use this tool versus alternatives like ir_get_guidelines or other load_context 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?

Annotations already provide readOnlyHint=true and idempotentHint=true, so the description adds meaningful context beyond them. The local-only, no-upload behavior is explicitly disclosed, which is not implied by the annotations and addresses a real concern with review tools.

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

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

The description is three sentences, front-loaded with the core purpose, then the return value, then the critical privacy note. Every sentence contributes meaningful information and there is no redundancy or filler.

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

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

The description fully covers what the tool does, what it returns, its key constraint (no report upload), and its reference items (rating sheets). For a read-only tool with complete schema annotations and no output schema, it is contextually 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 100% parameter description coverage, so the description doesn't need to re-explain the parameters. It does link the 'sections' parameter to 'what to check in each section' and the 'focus' parameter to 'writing quality issues', but this adds minimal value beyond the schema.

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

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

The description explicitly states the action ('Get Lenny Zeltser's expert criteria'), the resource ('reviewing an existing IR report'), and the deliverable ('focused guidance for constructive critique'). It distinguishes itself from sibling domain-review tools by mentioning the IR-specific rating-sheet items (lens taxonomy, Information sheet).

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

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

The description clearly implies when to use it: when the user wants expert IR review criteria without sharing the report itself. The statement 'This server never requests your report and instructs your AI to keep it local' clarifies a key usage constraint. It doesn't explicitly name alternatives or exclusions, but the context is strong.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds substantial behavioral context beyond that: it never requests sample data, analysis notes, or indicators, and instructs the AI to keep them local. It also discloses that the tool returns a compact subset of `malware_load_context`. There is no contradiction with 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 three sentences, each with clear purpose: the first states the function, the second explains the relationship to a sibling, and the third covers privacy behavior. No filler or redundancy; every sentence earns its place.

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

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

Considering this is a zero-parameter, read-only tool with no output schema, the description is remarkably complete. It covers the purpose, the trigger condition (unfulfilled requests), the relationship to a related tool, and the privacy posture. There is no missing information that would hinder an AI agent from selecting and invoking this 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?

The tool has zero parameters and the schema is empty, so description needs to explain nothing about parameters. The per-rubric baseline for 0 params is 4, and the description does not confuse or add irrelevant parameter information.

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

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

The description uses the specific verb 'Get' and names the exact resource: 'Lenny Zeltser's Malware cross-server handoff routes.' It further clarifies the purpose by stating it identifies which other MCP servers to consult when the current server cannot fulfill a request, and distinguishes itself from the sibling `malware_load_context` by being a compact subset.

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

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

It explicitly states when to use it: 'when this MCP server can't fulfill a request.' It also implies a comparison with `malware_load_context` by calling itself a 'compact subset,' suggesting that for full context one would use the other tool. However, it does not explicitly name an alternative with a direct 'use X instead' style.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds meaningful context about privacy: the server never requests the user's sample/analysis and instructs keeping them local, which is beyond annotations. It also clarifies the output structure (primary frameworks plus optional sibling frames). No contradiction with 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 compact, with the purpose front-loaded in the first sentence. The second sentence covers parameter usage, and the third adds privacy guidance—each sentence serves a distinct purpose without redundancy. It balances brevity with necessary details.

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

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

For a simple one-parameter read tool with no output schema, the description adequately explains what is returned (primary and optional sibling frameworks), how to control siblings, and data-handling expectations. It also ties the tool to the brief generation workflow, making its role clear despite not detailing the exact response structure.

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 already documents include_siblings with full coverage. The description adds practical meaning by explaining the effect of setting it to false ('skip sibling blocks') and by describing what sibling frames are (adjacent frameworks with whyOmitted notes). This goes beyond the schema's basic boolean description.

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 it retrieves Lenny Zeltser's Malware frameworks, explicitly distinguishing primary frameworks from optional sibling frames. It names the specific resource and verb (get), and the mention of 'primary frameworks the brief structurally derives from' differentiates it from domain-specific sibling tools like assessment_get_frameworks or cti_get_frameworks.

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?

Provides clear context that this is for malware briefs and explains how to control sibling inclusion with the include_siblings parameter. It also notes that the server never requests samples or indicators, guiding the AI on privacy handling. However, it doesn't explicitly state alternatives or when not to use this tool versus other framework 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds substantial behavioral context beyond that: 'This server never requests your sample, analysis notes, or indicators and instructs your AI to keep them local.' This privacy-preserving behavior is critical for the agent's trust assessment. It also explains the deferral behavior for certain topics, which is not obvious from the 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 two sentences, front-loaded with the core purpose. The first sentence names the resource and lists topics. The second sentence packs important usage notes (deferral, pairing, privacy) without redundancy. Every sentence earns its place; no unnecessary words.

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

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

For a read-only tool with no output schema, the description gives enough context: it clarifies that topics defer, how field_id works, and that results flow locally. It doesn't enumerate the full topic list (the schema does), and it doesn't describe the output format, but given the simplicity of the tool, this is sufficient. Slightly more detail on return value could bump it to 5, but not necessary.

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 provides full descriptions for both parameters (topic enum and field_id), so the baseline is 3. The description adds value by explaining the relationship between topic and field_id ('Pair the 'fields' topic with field_id') and noting that topic defaults to a 'summary' overview. This enriches the schema semantics, especially for the field_id parameter that only has meaning in a specific topic context.

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

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

The description opens with a specific action and resource: 'Get Lenny Zeltser's expert malware analysis report writing guidelines.' It clearly distinguishes this from sibling tools by naming the exact domain (malware analysis) and topic set, and even notes that some topics defer to another tool, get_security_writing_guidelines. This makes the tool's purpose unmistakable.

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

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

The description provides explicit usage context: it states which topics (tone, words, structure, executive_summary) should be deferred to a different tool, and it instructs pairing the 'fields' topic with field_id for single-field guidance. It does not explicitly compare against other malware_* siblings, but the deferral and pairing instructions give clear when-to-use and when-not-to-use guidance.

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

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

Beyond the annotations (readOnlyHint=true, idempotentHint=true), the description discloses a key behavioral trait: the server never requests sensitive data and directs the AI to keep local data local. This is critical context for an agent deciding whether to invoke the tool, and it adds value beyond the structured 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 three sentences: a clear purpose, a detailed yet valuable enumeration of report sections, and a privacy note. Each sentence earns its place, and the key information is front-loaded in the first sentence.

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

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

For a zero-parameter tool with no output schema, the description is complete: it specifies exactly what template is returned, outlines its sections, and explains the server's data-handling behavior. An agent has all necessary information to select and invoke the tool 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?

The tool has zero parameters, so the schema is trivially 100% covered. The description appropriately focuses on the template's content and server behavior instead of parameters, which is the correct baseline for a no-parameter 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 opens with a specific verb and resource: 'Get Lenny Zeltser's malware analysis report template.' It then enumerates the report's sections, clearly distinguishing this tool from sibling get_template tools for other domains (e.g., cti_get_template, ir_get_template).

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 strong context by stating the server never requests samples, notes, or indicators and instructs the AI to keep them local, implying this is a safe template-retrieval option. However, it does not explicitly contrast with sibling tools like malware_get_guidelines or malware_get_frameworks, so usage exclusions are only implicit.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds meaningful behavioral nuance: it explicitly states the server never requests samples/notes/indicators and instructs the AI to keep data local. It also clarifies that the 'profile' parameter annotates rather than filters, which is a non-obvious 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 well-structured and front-loaded with the main purpose, followed by return content and then parameter clarification. Each sentence serves a distinct purpose, though it is somewhat long and could be trimmed without losing meaning.

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 output schema, the description adequately covers what the JSON payload contains (section guidance, MBC, ICD-203, Pyramid-of-Pain, briefPolicy) and how the profile parameter behaves. It also provides essential privacy context. This is complete enough for an agent to decide when and how to invoke the 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?

Schema coverage is 100%, so the baseline is 3. The description adds extra semantic value by explicitly explaining that 'profile' annotates sections rather than filtering, resolving a potential interpretation ambiguity. Other parameters like topics and detail_level are already well-described in the schema, so no further compensation is needed.

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

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

The description clearly identifies the tool as loading Lenny Zeltser's malware analysis report writing context for local analysis, which is a specific verb+resource pairing. It further lists the distinct contents (MBC model, ICD-203 confidence, Pyramid-of-Pain, briefPolicy) that distinguish it from sibling tools like malware_get_template or malware_get_guidelines.

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 states the tool is for 'local analysis' and emphasizes that it does not request sensitive data, implying it is a safe context loader. However, it does not explicitly contrast with alternatives like malware_get_guidelines or malware_get_template, so the usage context is clear but exclusion criteria are only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond annotations: it explicitly states that this server never requests sample data/indicators and instructs the AI to keep materials local, which is valuable privacy-relevant 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 two well-structured sentences, front-loaded with the primary purpose, followed by a compact enumeration of content areas and a privacy note. Every phrase adds relevant information, with no redundancy or filler.

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

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

With zero required parameters and no output schema, the description should explain what the tool returns. It does this reasonably by stating it 'surfaces' review criteria and mentions the flow of guidelines and template for local analysis. It could be slightly more explicit about output format, but for selection and invocation the core information is present.

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% and the parameter descriptions already list allowed enum values. The description adds value by naming review themes (identification, capabilities, indicators, evidence, ecosystem, detection) and mentioning cross-cutting criteria and anti-patterns, giving the agent semantic context for choosing focus and section parameters.

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

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

The description opens with a specific verb and resource: 'Get Lenny Zeltser's expert criteria for reviewing an existing malware analysis report.' It further enumerates concrete content themes (identification, capabilities, indicators, evidence, etc.), which clearly differentiates this tool from sibling tools like malware_get_template or malware_get_guidelines.

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

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

The description clearly implies when to use this tool: when reviewing an existing malware analysis report. It gives no explicit exclusions or alternatives, but the stated purpose and the 'never requests your sample' privacy note provide practical context for appropriate invocation.

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

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

Annotations already cover read-only and non-destructive behavior. The description adds valuable context: the server never requests product plans and instructs the AI to keep them local, plus guidelines flow locally for analysis. This goes beyond the annotations, though it doesn't detail the exact output format or error conditions.

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

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

Three sentences, each earning its place: purpose, return values, and privacy behavior. The description is front-loaded with the core action and stays concise without redundant phrasing or repetition of schema details.

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

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

Given no output schema, the description lists all return components (rubric, dimensions, evidence tiering, comparison-specific instructions) and covers a crucial behavioral requirement (content must be supplied). It also addresses privacy and local analysis, making it sufficient for an agent to decide and invoke without ambiguity.

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 already provides 100% coverage for all parameters, so baseline is 3. The description adds some semantic link by mentioning 'comparison-type-specific instructions' (relating to comparison_type) and 'structured scoring rubric' (relating to include_scoring_rubric), but it does not delve into parameter syntax or constraints beyond the schema.

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

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

The description specifies a clear verb ('Load'), a distinct resource ('Lenny Zeltser's comparative analysis framework'), and a precise purpose ('evaluating multiple security companies side by side'). It also lists what is returned (scoring rubric, evaluation dimensions, evidence tiering guidance), clearly distinguishing it from generic context loaders like product_load_context.

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

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

The description implies when to use the tool: when you need a comparison framework for multiple security companies. It mentions 'Requires comparative analysis content,' which sets a precondition. However, it does not explicitly name alternatives or say when not to use it, leaving a slight gap in direct guidance against 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?

The description adds a meaningful behavioral note beyond the annotations: the server never requests product plans and keeps guidelines local for analysis. This complements the readOnlyHint and idempotentHint annotations, providing context about privacy and data handling. It does not contradict the 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 functional but lengthy, with a massive list of topics and parenthetical explanations squeezed into a single paragraph. It front-loads the purpose well but lacks structured formatting (e.g., bullets) and contains redundant enumeration that overlaps with the schema's enum.

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

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

For a simple tool with one optional parameter and no output schema, the description is fairly complete. It covers what the tool returns (guidelines), the available topics, and the privacy behavior. It doesn't specify return format, but that's not critical given the context. The sibling differentiation could be stronger, but the product focus is clear.

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

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

The schema already describes the 'topic' parameter with an enum and description (100% coverage). The tool description goes further by explaining what each topic means (e.g., 'defensibility' as an 'AI-era defensibility rubric'), adding semantic value beyond the bare enum values.

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: retrieving Lenny Zeltser's expert strategic guidelines for product strategy topics. It specifies the exact resource (Lenny Zeltser's guidelines) and differentiates from sibling tools like cti_get_guidelines or ir_get_guidelines by focusing on the product domain.

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 product strategy questions by listing the available topics, but it does not explicitly state when to use this tool versus alternatives (e.g., product_get_template or other get_guidelines tools). No exclusions or alternative guidance is provided.

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

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

Annotations already declare read-only and idempotent, and the description adds meaningful behavioral context: the server never requests product plans, instructs the AI to keep them local, and clarifies copyright ownership. This goes beyond the structured annotations without contradicting them.

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

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

Three sentences, front-loaded with the primary purpose, followed by content details and a privacy/ownership note. Every sentence contributes valuable information with no 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 simple parameterless template retrieval, the description covers what the template includes, the privacy behavior, and copyright terms. No output schema exists, but none is needed for this straightforward 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?

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add. Baseline for 0 parameters is 4.

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

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

The description opens with a specific verb+resource: 'Get Lenny Zeltser's fill-in-the-blank template for planning a security product strategy.' It clearly distinguishes from sibling templates by naming the specific template and domain (security product strategy), and from product_get_guidelines by specifying it is a fill-in-the-blank template.

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 planning a security product strategy but does not explicitly state when to choose this over sibling tools like product_get_guidelines or other domain templates. The privacy note hints at a safe use case but no alternatives or exclusions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: it never requests plans and instructs AI to keep them local, a privacy-related trait. It also describes output size behavior via detail_level token counts, which is not in 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 fairly long but efficiently front-loaded with purpose and then parameter details. Every sentence adds information about usage, privacy, or parameter behavior. It is appropriately sized given 9 parameters, though a slightly more concise version might exist.

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?

Despite lacking an output schema, the description mentions what is returned (frameworks, rating-sheet items, lens taxonomy) and covers privacy, parameter selection, and relationships to other tools (e.g., include_template saves a product_get_template call). No important aspect seems missing for a context-loading 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?

Schema coverage is 100%, so baseline is 3. The description adds extra meaning: detail_level token estimates ('~2k tokens', '~5k tokens') and compact meaning 'all sections but stripped', market_segment 'smb' for SMB-specific guidance, product_focus 'endpoint' for endpoint security viability. This exceeds what the schema alone provides, justifying a 4.

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 'Load Lenny Zeltser's product strategy context for local analysis' and describes what it returns: 'expert strategic frameworks, principles, and guidance'. This is a specific verb + resource + purpose, clearly distinguishing it from siblings like product_compare_context and product_review_plan.

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, such as 'This server never requests your plans and instructs your AI to keep them local' and parameter guidance for controlling response size. It also mentions 'Saves a separate product_get_template call' for include_template, naming an alternative. However, it doesn't explicitly exclude other contexts or 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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context beyond that: output contents (section checks, coherence issues, collaborative framing, rating-sheet taxonomy) and a privacy guarantee ('never requests your plan'), which enriches transparency.

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, then covers behavioral details and parameter usage. It's slightly verbose with redundant parameter guidance, but each sentence serves a distinct function and the structure is logical.

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 no output schema, the description explains the nature of the returned guidance, the privacy behavior, and key parameter effects. It doesn't enumerate all output fields but gives enough context for an agent to invoke it appropriately.

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 descriptive enum values, so the description adds little beyond the schema. It repeats the SMB/endpoint parameter hints but doesn't clarify the focus or sections arrays further; this is adequate given the schema's completeness.

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?

Description opens with a specific verb+resource: 'Get Lenny Zeltser's expert criteria for reviewing an existing product strategy plan.' This clearly states what the tool does and distinguishes it from siblings like product_get_guidelines or rating_get_sheet by focusing on plan review criteria.

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 use (reviewing existing product strategy plans) and explicit parameter usage hints for market_segment and product_focus. It doesn't name alternatives or exclusions, but the context is sufficient to guide selection among 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, but the description goes further by disclosing that the server never requests the user's draft and instructs the AI to keep content local. It also clarifies the tool returns the structured rubric and not computed scores, adding context beyond the 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 three sentences, each with a distinct purpose: state what the tool does, contrast with the scoring sibling, and disclose privacy behavior. It is front-loaded with the core purpose and contains no redundant or filler content.

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

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

For a simple read-only tool with one parameter and no output schema, the description fully explains what is returned (structured rubric with groups, items, scoring bands), what is not computed (score), and how to get scoring if needed. It also covers the privacy behavior, making it adequate without an output schema.

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 covers 100% of the single parameter (sheet) with a clear description of each enum value, so the schema itself does the heavy lifting. The tool description adds no additional parameter-level detail beyond the schema, so a baseline score of 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 opens with a clear, specific verb (Get), identifies the resource (Lenny Zeltser's cybersecurity-writing rating sheet), and explains its purpose (apply the rubric). It explicitly distinguishes itself from the sibling tool rating_score_writing by stating it does NOT compute a score, making its scope unmistakable.

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

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

The description gives explicit guidance: use this tool when you need the rubric without scoring, and directs users to rating_score_writing when they also want a numeric score, gap analysis, or rubric-anchored feedback. This directly addresses when to use this tool versus the most relevant sibling.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint false. The description adds meaningful behavioral context beyond this: 'This server never requests your draft and instructs your AI to keep it local—rating sheets and scoring instructions flow to your AI.' This privacy/data-flow detail is not derivable from annotations and is useful for the agent.

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

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

Two sentences, no wasted words. The first sentence captures the core action and contents; the second provides a key privacy constraint. Information is front-loaded and every sentence earns its place.

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

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

For a simple load-context tool with one optional parameter and no output schema, the description is complete: it lists the contents loaded, mentions the privacy/behavioral policy, and is easy to understand. It lacks explicit guidance on when to use this versus related tools, but that is covered by dimension 2 and does not undermine overall completeness for this simple action.

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 fully describes the single optional parameter 'detail_level' with enum values and token estimates, so schema coverage is 100%. The description adds no additional parameter information. Baseline 3 is appropriate because 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 uses a specific verb 'Load' with a clear resource: 'Lenny Zeltser's complete cybersecurity-writing rating toolkit', enumerating 'all 7 sheets, scoring policy, scoring playbook, and cross-references to the writing guidelines.' This distinguishes it from sibling tools like rating_get_sheet (which likely loads a single sheet) and other domain-specific load_context 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 description implies when to use this tool—when you need the full toolkit—but does not explicitly state alternatives or exclusions. It does not mention that rating_get_sheet should be used for individual sheets or that this tool is the comprehensive version. No direct comparison to siblings is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable context: it clarifies that the server never requests the draft and instructs the AI to keep it local, explaining data flow. It also states what it returns (rubric + instructions). No contradiction with 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 appropriately sized, with the primary purpose front-loaded in the first sentence. Each subsequent sentence earns its place: differentiation, return content, and privacy. Despite the all-caps emphasis, it is 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?

The description covers purpose, return content, and data flow, which is sufficient for a read-only tool with rich schema information. However, it does not elaborate on the output structure (e.g., format of numeric scores) or how modes differ, though these are partially explained in the schema. Minor gap given no output schema.

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% and every parameter has detailed descriptions including enums. The tool description itself does not add any parameter-specific semantics beyond what the schema already provides. Baseline 3 is appropriate as the schema carries 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 specifies a clear verb+resource: 'Get Lenny Zeltser's scoring playbook' for scoring drafts against a cybersecurity-writing rating sheet. It explicitly distinguishes itself from writing-coach tools by claiming it's the only one producing numeric scores, making its unique purpose unmistakable.

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

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

It provides explicit guidance on when to use this tool: when numeric scoring is needed. It names alternatives that do not score (`get_security_writing_guidelines`, `ir_*`, `product_*`), effectively telling the agent that these are not suitable for scoring. This goes beyond implied usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds search scope (titles, abstracts, full content, topics) but does not disclose pagination behavior, rate limits, or other operational details, offering only modest additional 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 three concise, front-loaded sentences with no wasted words. Each sentence contributes relevant information about the tool's purpose and 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?

For a simple search tool with 2 parameters, good annotations, and an output schema, the description is sufficiently complete. It does not need to explain return values since the output schema exists, and it clearly conveys the tool's function and scope.

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

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

The schema provides 100% coverage for both parameters (query and limit) with clear descriptions. The description adds no additional semantic meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states the tool searches Lenny Zeltser's website by keywords, listing content types and search scope. This distinguishes it from sibling tools like get_article, which likely retrieves a specific article.

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

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

The description provides clear context for when to use the tool (searching across titles, abstracts, full content, and topics) but does not explicitly mention alternatives or exclusions. The verb 'search' implies the use case relative to siblings like get_article, but it is not explicitly stated.

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

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

The description discloses meaningful behavioral traits beyond annotations: 'This server never requests your vulnerability notes and instructs your AI to keep them local—the brief template and guidelines flow to your AI for local analysis.' This adds privacy and data-handling context not present in the read-only/idempotent 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 purpose, and every sentence adds distinct value. No filler or 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?

The description fully covers purpose, variant differentiation, privacy behavior, and what the tool returns ('brief template and guidelines flow to your AI'). Given no output schema, this is sufficient for the simplicity of the 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 zero parameters, so the schema already covers everything (100% coverage). The baseline for zero parameters is 4, and the description has no need to add parameter info. No gaps exist.

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 it 'Get Lenny Zeltser's Vuln one-page executive brief template', specifying the exact resource. It also distinguishes from the sibling `vuln_get_template` by calling itself a 'Standalone variant', and from other domain templates by mentioning 'Vuln'.

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: 'Standalone variant of `vuln_get_template` for callers that only want the brief without the long-form report.' This directly indicates when to use this tool versus the alternative. It also describes the local-analysis context, reinforcing the intended use case.

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

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

Annotations already cover read-only, idempotent, and non-destructive semantics. The description adds useful behavioral context: it never requests vulnerability notes, instructs the AI to keep them local, and surfaces only a compact subset of vuln_load_context. This goes beyond annotation basics without contradicting them.

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 purpose, and contains no redundant phrasing. The privacy note is slightly tangential but adds valuable context without bloating the text.

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

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

For a zero-parameter tool with no output schema, the description explains what to expect (cross-server handoff routes and fallback workflows) and its relationship to vuln_load_context. It could better describe the exact format of the returned routes, but it's adequate for a simple routing 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?

The tool has zero parameters, so the baseline of 4 applies. The description does not need to compensate for any schema gaps because no input schema 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 identifies the tool as returning cross-server handoff routes for the Vuln domain, with a specific use case ('when this MCP server can't fulfill a request') and distinguishes it from similar sibling tools via the domain prefix and by referencing it as a compact subset of vuln_load_context.

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 the tool ('when this MCP server can't fulfill a request') and mentions an alternative (vuln_load_context) as a fuller context source. However, it does not explicitly enumerate when not to use it beyond implying that full context should come from load_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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful behavioral context beyond those: it discloses that the server never requests vulnerability notes and instructs the AI to keep them local, and it explains the optional sibling blocks. This goes well beyond the annotation baseline.

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

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

The description is three sentences, front-loads the core purpose, and contains no fluff. Every sentence adds substantive information, including usage and privacy behavior.

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 (one optional boolean parameter, no output schema, strong annotations), the description covers purpose, parameter behavior, and data handling. It does not detail the exact return structure, but the parameter description in the schema partially covers that, and the absence of an output schema makes some lack of return detail acceptable.

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

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

Schema coverage is 100% with a clear parameter description, so baseline is 3. The tool description adds value by explaining what sibling frames are (adjacent frameworks that aren't the structural backbone) and providing an explicit usage example ('Pass include_siblings: false'), enriching the schema's semantics.

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

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

The description uses a specific verb ('Get') and a specific resource ('Lenny Zeltser's Vuln frameworks'), and distinguishes primary frameworks from optional sibling frames. It clearly conveys that this tool retrieves the frameworks that structurally underpin a brief, differentiating it from sibling get_frameworks tools for other domains.

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

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

The description provides clear context for when to use the tool (to obtain the structural frameworks and optionally adjacent sibling frames) but does not explicitly name alternatives or state when not to use it. It does, however, give a direct usage hint about the include_siblings parameter, which adds practical guidance.

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

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

Beyond the read-only, idempotent, non-destructive annotations, the description discloses a privacy behavior (server never requests vulnerability notes and keeps data local) and clarifies that the 'significance' topic is distinct from CVSS/vendor severity scoring. These add meaningful context not captured by 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 moderately long but front-loaded with the core purpose, followed by a topical list and key usage notes. Every sentence earns its place, though the density of topics makes it slightly less concise than ideal.

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 and the absence of an output schema, the description covers purpose, topics, parameter relationships, and a notable privacy behavior. It does not explicitly describe the return format, but the guidance-focused nature is clear, making it adequately 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?

Schema coverage is 100%, but the description adds value by explaining the relationship between topic and field_id, and by elaborating on several topic meanings (e.g., significance, actions, gaps). This enriches the parameter semantics beyond the schema descriptions.

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 retrieves Lenny Zeltser's expert vulnerability-brief writing guidelines, listing specific topics and explicitly distinguishing from sibling get_guidelines tools by domain (vulnerability briefs). The verb 'Get' plus the resource and scope make the purpose unambiguous.

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

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

It provides specific usage guidance, such as pairing the 'fields' topic with field_id for single-field guidance, and implicitly indicates this is the tool for vulnerability-brief guidelines. However, it does not explicitly contrast with alternative sibling tools or provide exclusion criteria, so it falls short of full explicit guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds meaningful behavioral context: the server never requests vulnerability notes and instructs the AI to keep them local, and the template/guidelines flow to the AI for local analysis. This goes beyond the annotations and clarifies data 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 two sentences, front-loaded with the main purpose, and each sentence adds distinct value (template contents, privacy behavior). No fluff or 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 zero-parameter, read-only template retrieval tool, the description covers what the template includes, the privacy/security behavior, and the local-analysis flow. It is sufficiently complete without needing an output schema.

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

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

The tool has zero parameters, so the schema fully covers parameter semantics. The description does not add parameter details, which is appropriate since there are none to document. Baseline 4 applies.

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

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

The description clearly states 'Get Lenny Zeltser's one-page Vulnerability Advisory Brief template' and lists the included sections, making the tool's purpose specific and distinct from sibling template tools for other domains (e.g., cti_get_template, ir_get_template).

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

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

The description implies when to use the tool by specifying the vulnerability advisory context and the sections covered, but it does not explicitly name alternative tools or state 'use this instead of X.' The privacy context ('never requests your vulnerability notes... local analysis') gives additional situational clarity.

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

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

Annotations already indicate readOnly and idempotent, and the description adds significant behavioral context: it always embeds mcpHandoffs, never requests vulnerability notes, instructs AI to keep notes local, and clarifies the 'significance' terminology versus CVSS/vendor severity. No contradiction with 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 front-loaded with the core purpose, and every clause adds useful information (payload contents, handoffs, privacy stance, version note). It is somewhat long but dense and well-structured; no wasted sentences.

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

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

With no output schema, the description does an excellent job explaining what the tool returns: JSON payload, specific elements (brief section guidance, completeness criteria, significance, frameworks), and the handoffs array. It also covers the privacy behavior and version note, making it fully adequate for such a feature-rich 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?

Schema description coverage is 100%, so parameter meanings are fully documented in the schema. The tool description does not add any parameter-specific detail beyond what the schema already provides, so 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 names a specific verb ('Load') and resource ('Lenny Zeltser's Vulnerability Investigation Brief context') and enumerates the payload contents (section guidance, completeness criteria, significance discipline, evidence sources, frameworks). It distinguishes itself from siblings by explicitly mentioning the mcpHandoffs array that points to other tools like rating_score_writing and cti_load_context.

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?

Clear context is provided: this is for loading the Vuln Brief context for local analysis, and the mcpHandoffs array tells the AI when to reach for alternative tools (e.g., rating_score_writing). However, it does not explicitly state when NOT to use this tool or directly compare with sibling load/template tools, so it stops short of a 5.

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

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

Annotations already mark this as read-only and idempotent. The description adds meaningful behavioral context: it surfaces cross-cutting criteria, anti-patterns, and inline mcpHandoffs pointers, and explains that the server never requests vulnerability notes and keeps the brief local for analysis. No contradiction with 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 three sentences, with the purpose front-loaded. Each sentence contributes: purpose, contents/outputs, and privacy behavior. It is slightly dense, but no sentence is wasted.

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 output schema, the description adequately indicates what is returned (per-theme criteria, cross-cutting criteria, anti-patterns, pointers). It is complete enough for a moderate-complexity tool, and the privacy note adds important context for this type of server.

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

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

Schema coverage is 100% for both parameters. The description adds extra meaning by giving a concrete example ('focus=tone surfaces rating_score_writing') and explaining the focus-driven behavior beyond the enum list. This goes beyond what the schema alone provides.

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 'Get Lenny Zeltser's expert criteria for reviewing an existing Vulnerability Investigation Brief' – a specific verb, resource, and expert source. It distinguishes from sibling tools like vuln_get_guidelines by naming Zeltser and the review focus, and by listing unique outputs (per-theme criteria, anti-patterns, mcpHandoffs pointers).

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 reviewing existing Vulnerability Investigation Briefs and gives an example of focus-triggered handoffs, but it does not explicitly compare to alternatives like vuln_get_guidelines or other review tools. There's no when-not-to-use guidance, so it stays at implied usage.

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