snapmcp

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful behavioral context: 'Each capture is processed sequentially with its own parameters' and 'Maximum 10 captures per call.' However, the max limit is already in the schema, and the description does not cover failure behavior, what happens if one capture fails, or file-output side effects beyond what the schema's output parameter implies.

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: three sentences covering purpose, batch use case, and the key 10-capture limit. The limit repeats schema maxItems, but restating it in the description is helpful for quick scanning. The example earns its place by making the batch intent concrete.

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 batch wrapper tool with a rich schema and many sibling tools, the description clarifies why an agent would choose capture_batch over single-capture tools. It does not explain output structure or error handling, but the schema covers per-capture parameters and the output directory, so the description is largely sufficient 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?

Schema description coverage is 100%, so the schema already documents the captures array and its per-type properties in detail. The description's mention that 'Each capture is processed sequentially with its own parameters' adds little semantic value beyond the schema, which fully specifies the oneOf structure. 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 states a clear verb and resource: 'Capture multiple items in a single call.' It is immediately distinguishable from single-capture siblings like capture_terminal and capture_browser because it frames itself as a batch operation. The example ('capture terminal output, code file, and browser screenshot together') further clarifies the intended resource 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 gives explicit usage context: 'Use for batch documentation generation' and provides a concrete example of mixed capture types. It does not explicitly say when to avoid this tool in favor of single-capture siblings, but the batch versus single distinction is strongly implied by the wording and sibling names.

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

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

With no annotations, the description carries the full burden and does well: it discloses headless Chromium, optional Chrome-profile use, and SSRF protections including blocked IP ranges and DNS-rebinding defense. It does not fully describe the return value or post-capture behavior, such as whether a file path is returned, so a 5 is not justified.

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?

Four short sentences, each carrying distinct information: core action, authentication/profile behavior, SSRF safeguards, and capture modes. The most important facts are front-loaded with no 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 5-parameter tool with no annotations and no output schema, the description plus schema is nearly sufficient: it covers purpose, security behavior, profile behavior, and all parameters. The main gap is that the result format is not described, and there is no explicit guidance distinguishing this tool from its many capture_* siblings.

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

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

Schema description coverage is 100%, so the schema already thoroughly documents url, width, height, output, and fullPage. The description adds useful environment-variable context (SNAPMCP_CHROME_PROFILE, SNAPMCP_SSRF_PROTECTION) but no additional parameter-level meaning, matching the high-coverage baseline of 3.

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

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

The description opens with a specific verb and resource: 'Take a screenshot of a URL using headless Chromium.' This immediately distinguishes capture_browser from siblings like capture_pdf or capture_html by anchoring on URL and screenshot behavior. The full-page/viewport detail further clarifies 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 gives clear usage context: it is for URL screenshots and explicitly mentions when the Chrome profile is relevant for authenticated sessions, cookies, and extensions. It does not explicitly name alternative tools or state when not to use this tool, 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?

With no annotations, the description carries the full burden. It discloses rendering behavior such as line numbers, theme-aware colors, and optional window chrome, but it does not mention side effects like creating an output file, where it is written, or how themes and window chrome are controlled given the schema has no parameters for them. This leaves some ambiguity about the actual tool 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?

Three sentences with a clear hierarchy: action, features, use cases. It is appropriately sized, though the closing phrase 'authentic IDE-like appearance' is slightly promotional and the mention of 27 themes is not reflected in the input 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?

The description is adequate for invoking the tool: it explains what is rendered and for what use cases, and the schema covers all parameters. However, with no output schema, the tool description does not state what the tool returns, such as a file path or confirmation, and it does not clarify output-side behavior. This is a gap for a tool with no annotations and 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%, so the schema already documents all parameters sufficiently. The tool description adds high-level context about languages and themes but does not explain individual parameters beyond what the schema provides, so it meets the baseline for high schema coverage.

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

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

The opening clause, 'Generate a syntax-highlighted code screenshot using Shiki,' names a specific action and resource. It clearly distinguishes this tool from siblings like capture_terminal or capture_markdown by focusing on code rendering with line numbers and IDE-like styling.

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: 'Ideal for code documentation, tutorials, and sharing snippets.' It does not explicitly list exclusions or alternatives, but the use cases are concrete enough for an agent to select this tool for code-screenshot 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?

With no annotations, the description carries the full burden. It discloses parsing behavior, displayed elements, and a 500KB size limit, which is useful. But it does not state whether the tool writes an image file, what the output artifact is, or any side effects — details only partially covered by the schema's output parameter.

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 and front-loaded with the primary action: 'Render a git diff with color-coded additions and deletions.' Each sentence adds relevant context — parsing, display elements, use cases, and size limit — without redundancy.

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

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

For a tool with two parameters and no annotations, the description covers input format, size limit, rendering features, and ideal use cases. It omits explicit output format or mechanics, but the schema's output parameter fills that gap. This is adequate for a straightforward capture 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 the baseline is 3. The description reinforces the diff format requirement and size cap, but these are already present in the schema's diff parameter. The output parameter is adequately described in the schema, so the description adds minimal parameter-level value.

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

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

The description opens with a specific verb and resource — 'Render a git diff with color-coded additions and deletions' — and distinguishes itself from sibling capture_* tools by specifying unified diff input and rendering features. It clearly identifies the tool's unique function within the capture family.

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 'Ideal for PR reviews, migration guides, and change documentation,' which signals appropriate contexts. It also defines the accepted input format (unified diff), implying it should be used only when data is in that format. However, it does not explicitly name alternative sibling tools or state when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool reads a file, is security-config dependent with deny-all default, has a maximum file size, and supports automatic language detection. It does not explicitly mention all failure modes or whether it writes output to disk, but the read-only implication is clear.

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 with no filler: the first states the core action, the second highlights language support, and the third covers security and size limits. Information is appropriately 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 tool with no output schema and no annotations, the description covers key operational details but omits the return value/format and any error behavior. It also does not situate the tool among its many siblings, leaving some ambiguity for an agent deciding whether capture_file is the right choice.

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 useful behavioral constraints such as file extension-based language detection and the 5MB maximum, but these are not essential to understanding individual parameters beyond what the schema already documents.

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 specific function: reading a file and generating a syntax-highlighted screenshot with automatic language detection. This distinguishes it from siblings like capture_terminal or capture_browser, though it doesn't explicitly differentiate it from the similarly-named capture_code.

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

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

The description provides no guidance on when to use capture_file versus its alternatives. It only notes prerequisites and constraints (SNAPMCP_ALLOWED_PATHS, 5MB limit), but does not explain selection criteria or exclusions relative to the many sibling tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It mentions constraints like 'Maximum 60 frames, maximum canvas 8192x8192', which is good. However, it does not disclose other behaviors such as how output is returned (file path?), whether it is synchronous, or potential side effects (e.g., temporary files). This is a moderate gap but not contradictory.

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

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

The description is concise, with the primary purpose in the first sentence and key constraints (max frames, canvas) early. Sentences are efficient and avoid redundancy. The mention of use cases adds a little length but is valuable for guidance, so 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?

Given the complex input schema with seven capture types, the description provides a high-level overview but omits details like the specific frame types (terminal, code, etc.) and that each has its own parameters. However, the schema itself documents these thoroughly, so the description doesn't need to repeat. It does not explain the return value, but with no output schema, a note on what to expect (e.g., a file path) would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including nested types. The description adds minimal value beyond the schema, but it does clarify the overall flow (frames are captured sequentially) and reinforces the min/max frames. The schema covers parameter meaning well, so this is adequate.

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 that the tool creates an animated GIF from sequential captures, and explains that frames are captured with full type-specific parameters. It distinguishes itself from siblings (which likely capture single frames) by focusing on animated GIF output. The use cases (animated tutorials, before/after comparisons, step-by-step demonstrations) provide clear 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 explains when to use this tool (for animated content) and implies that it is the right choice over single-capture siblings. However, it does not explicitly mention when NOT to use it (e.g., for a single frame, where a sibling would be more appropriate). The example use cases give good context, but explicit alternatives are not named.

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

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

With no annotations, the description carries the full burden for behavior disclosure dispusa. It clearly states sanitization, blocking of external resources, the 200KB maximum, and viewport/chrome rendering behavior. It does not describe the return value or failure modes, but it does cover the most important constraints for safe 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?

The description is four sentences with no wasted words: purpose, use cases, rendering context, and security constraints are each given one tight sentence. The most important 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 simple 3-parameter tool with no output schema and no annotations, the description covers what the tool does, when to use it, and the key constraints needed to use it correctly. It could improve by pointing to alternatives like capture_browser for live pages, which is the only notable 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?

Schema description coverage is 100%, so the baseline is 3. The description repeats the 200KB limit and external-resource blocking already present in the schema but does not add meaningfully new parameter semantics. The 'optional window chrome' note is minor supporting context, not a substantive parameter clarification.

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 and object ('Render arbitrary HTML as a screenshot') and immediately clarifies the special value ('with full CSS support'). It also lists concrete use cases, distinguishing this from sibling capture_* tools that target Markdown, browser pages, or files.

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?

An explicit 'Use for' clause gives clear selection context: custom UI previews, email templates, dashboard widgets, and general HTML/CSS content. It does not name alternatives or state when not to use this tool, so it falls just short of a 5.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses significant traits: rendering with a configured Shiki theme, support for HTML, the specific limitation that mermaid diagrams are rendered as text, and a maximum input size of 200KB. It does not mention output-file side effects or return values, which keeps it from a 5.

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 and front-loads the core purpose before adding supporting details. Every sentence contributes either a capability, a rendering behavior, or a constraint, with no fluff or redundant restatement of the tool name.

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 rendering tool with no output schema and no annotations, the description covers input constraints and rendering features well but omits what the tool returns or where the output screenshot is written. It is useable but not fully self-sufficient for an agent that needs to consume the produced artifact.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics beyond the schema. It reveals mermaid-as-text behavior, HTML support, and Shiki theme rendering, which directly affect how the markdown parameter's content will be interpreted and displayed.

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 opening sentence, 'Render Markdown as a styled document screenshot using GitHub-flavored Markdown,' names a specific action, resource, and output artifact. It further differentiates itself from siblings by listing supported features (tables, task lists, code blocks, mermaid as text, HTML) that are unique to Markdown rendering.

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

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

The description implies usage when Markdown content needs to become a styled screenshot, but it never explicitly states when to prefer this over alternatives like capture_html or capture_code, nor does it explain when not to use it. The context is clear but exclusions and sibling routing are left to inference.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses headless Chromium usage, lazy-loaded content handling, full-page vs viewport behavior, Chrome profile authentication, and SSRF protections. This goes substantially beyond what the schema alone conveys.

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 compact sentences with no filler. It front-loads the core purpose, then adds behavioral details that matter for invocation, such as SSRF restrictions and authenticated-page support. 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 5-parameter tool with no output schema and no annotations, the description covers the key invocation-relevant aspects: conversion mechanism, rendering mode, authentication, and network restrictions. The main gap is that it does not describe the return value or output location, which is more impactful because no output schema exists.

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

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

Schema description coverage is 100%, so the parameters are already well documented in the schema. The description reinforces concepts like full-page vs viewport and custom viewport, but adds no new parameter-level meaning that the schema does not already provide.

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: 'Convert a URL to a PDF document using headless Chromium.' It clearly identifies the output format and distinguishes itself from sibling capture tools like capture_markdown or capture_html by focusing on PDF generation.

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

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

The description implies the tool's use case—producing print-quality PDFs from URLs—and mentions useful contexts like authenticated pages via the system Chrome profile. However, it does not explicitly state when to choose this over alternatives like capture_html or capture_to_document, 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?

With no annotations, the description carries the full burden. It discloses the 60-step limit and optional GIF generation, adding useful behavioral context. However, it does not mention file system effects, output directory behavior, overwriting, or execution time, which are important for a multi-file creation tool.

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

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

Two sentences, front-loaded with the core purpose, then use cases, then the key 60-step constraint. Every sentence earns its place; no waste.

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

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

The description gives the essentials for a complex tool with many nested parameters Gang, but does not enumerate supported step types (terminal, code, file, etc.) nor mention output directory defaults. Given the extremely rich schema, this is a minor gap; the agent can rely on schema details.

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 detailed descriptions for all top-level parameters and each nested step object. The description only generically references 'type-specific parameters' without adding semantics beyond the schema; the baseline 3 applies because the schema carries the load.

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 clearly states a specific verb ('Capture'), resource ('each step of a process as individual image files + optional compiled GIF'), and scope ('sequence'). The mention of stepNumber/label and 'Maximum 60 steps' distinguishes it from the single-step sibling capture 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 provides explicit use cases ('CI/CD pipeline visualization, deployment steps, tutorial sequences'), which makes the intended context clear. It does not explicitly name alternative single-step tools or say when not to use this tool, but that is implied by the contrast with sibling names.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers a genuinely non-obvious trait: automatic theme detection (Kitty, GNOME, Alacritty, WezTerm, etc.) that determines prompt colors. It doesn't disclose the return value or file-write side effects in the description, but the core generation behavior is transparent.

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

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

Three sentences, each earning its place: core function, behavioral nuance, and use cases. The purpose is front-loaded in sentence one with no filler or redundant restatement of schema 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 modest-complexity tool with fully documented parameters, the description covers purpose, usage, and the key behavioral quirk. The main gap is that there is no output schema and the description never states what the tool returns (e.g., a file path or URL), though the output parameter's filename semantics imply a saved artifact.

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% — lines, title, and output each have inline documentation including the '$ '/ '# ' prompt-prefix rule and filename defaults, so the schema already carries the parameter semantics. The description adds theme-detection context that influences rendering but no per-parameter meaning, matching the baseline of 3.

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

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

The description opens with a specific verb and resource — "Generate a styled terminal screenshot from text lines" — and the terminal focus clearly differentiates it from capture_markdown, capture_code, and capture_html siblings. The phrase "with real terminal theme colors" further pins down the artifact type and rendering behavior.

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 closing sentence gives explicit use cases: "Use for CLI tutorials, command output documentation, and terminal-based guides." It provides clear context for when to select this tool, but it doesn't name alternatives or state when not to use it, so it stops 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does add value: it distinguishes output-format semantics (markdown uses image references, HTML is self-contained base64, PDF is print-quality) and states the 30-capture limit. However, it omits that the tool writes a file to disk and gives no hint of path/permission constraints (SNAPMCP_ALLOWED_PATHS appears only inside the captures schema) or SSRF protections for browser captures.

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 and front-loaded with the primary purpose in the first sentence. However, the third and fourth sentences ('Output formats: ...' and 'Maximum 30 captures per document.') duplicate information already present in the input schema's format enum descriptions and captures maxItems, so they do not fully earn their 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?

This is a complex tool with 5 top-level parameters and 7 capture variants inside the captures array. Although the schema is rich and carries most of the load, the description provides no usage guidance versus siblings, no indication of whether the result is returned or written to disk, and no mention of file-output constraints. It is minimally viable but has clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal value beyond the schema: 'rendered as an image' clarifies the rendering behavior for captures, but the format descriptions and 30-capture maximum simply restate what the format enum and captures maxItems already declare. No parameter meaning is lost, but nothing substantial is gained.

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 ('Create') and resource ('a document') and clarifies that each capture is rendered as an image and embedded, with optional captions. This differentiates it from the sibling capture_* tools, which produce single captures rather than composite documents, though it never names a sibling explicitly.

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

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

The description does not state when to choose this tool over capture_markdown, capture_browser, capture_pdf, or the other siblings. The 'step-by-step captures' wording implies an assembly/batching scenario and the 30-capture ceiling hints at scale, but there is no explicit when-to-use, when-not-to-use, or named alternative, leaving the agent to infer the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns a hint, implying a read-only operation, but doesn't explicitly mention that it creates no side effects or external calls. For this simple tool, the omission is not misleading, but it adds little beyond the obvious.

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 at two sentences, but there is slight redundancy: 'Return a helpful hint' and 'Provides contextual guidance' communicate essentially the same function. Still, it is front-loaded with the core purpose and avoids unnecessary detail.

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 enum parameter and no output schema, the description is mostly complete. It explains the tool's purpose and scope, and the schema covers the parameter. It doesn't specify the return format, but for a hint tool, a text string is naturally implied.

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

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

The input schema has 100% description coverage, with a single optional `topic` parameter fully enumerated and explained. The description adds no additional parameter semantics, so the baseline score of 3 is appropriate given the schema already handles the documentation.

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

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

The description clearly states the tool returns a helpful hint about configuring and using snapmcp, using a specific verb ('Return') and resource. It distinguishes itself from sibling capture_* tools, which are all about capturing content, making the tool's 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 clear context for when to use the tool: when needing guidance for setup, troubleshooting, or feature discovery. It doesn't explicitly mention alternatives, but the sibling tools are so different in purpose that no exclusion is necessary.

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