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

With no annotations, the description carries the full burden and does substantial work: 16:9 stage, play/pause/replay/progress controls, sequential scene playback, no external assets, and 'vary them per conversation' hinting at repetition control. It doesn't cover permissions, persistence, or error behavior, so it falls short of exhaustive.

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?

Purpose and routing condition are front-loaded in the first sentence, followed by rendering behavior and composition patterns. The dense last sentence earns its place by showing how the schema yields varied output, though it borders on repeating the scene-kind list.

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 high-complexity nested-scene tool with an output schema (so returns need no explanation), the description covers purpose, rendering behavior, and composition patterns well. Minor gaps remain around lifecycle and error cases, but nothing an agent needs to author a valid card is missing.

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 63%, and the description adds real meaning on top: per-scene transition and duration, the chart.zoom camera behavior into a label range, and shapes as diagram elements with arrows tracing in. It is silent on tutorTerms and contextActions, but those carry rich schema descriptions of their own.

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?

States a specific verb (render) and resource (short animated clip as a card) and pins the exact scope: 'when no direct video URL exists but motion would communicate better than static content'. This implicitly separates it from the sibling create_video_card without opening either schema.

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?

Gives clear when-to-use conditions ('explanations, walkthroughs, and data stories') and a negative trigger (no direct video URL exists), which routes the agent away from the video sibling. It stops short of naming the alternative tool explicitly, but the selecting condition is unambiguous.

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 behavioral burden. It does disclose output composition (SVG, legend, collapsible data table) and that the chart is 'dynamically generated,' which is useful. But it says nothing about rendering context, permissions, or side effects on the host.

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 tight sentences with the core capability front-loaded and no wasted words. Efficient for a complex tool, though the second sentence is too vague to fully earn 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?

An output schema exists so return values need no explanation, and the schema richly covers the nested tutorTerms/contextActions params. However, for a 10-parameter tool with no annotations, the description is thin on usage routing and rendering behavior, leaving real 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 coverage is 50% and the schema already documents that labels/series are for bar-line versus values for pie-donut, plus rich descriptions for tutorTerms and contextActions. The description's enumeration of chart types merely repeats the enum and adds no meaning beyond the schema, so baseline 3 fits.

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?

Names a specific verb and resource ('Render a dynamically generated SVG chart card') and enumerates the supported chart types (bar, line, pie, donut) plus the legend and collapsible data table it produces. This distinguishes it from sibling card tools like create_table_card or create_markdown_card, though it never names them directly.

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 only guidance is 'Use for useful graphics summarizing referenced data,' which is vague and offers no when-not-to-use or alternatives. Against a large sibling set of card creators, the description does nothing to route the agent to the right one.

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

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

No annotations exist, so the description carries the full burden, and it delivers: ordering rules (explicit order with README/manifests hoisted; archive order README, manifest, src), the ~32,000-character part split and why small files still split, the exact resume loop against structuredContent.parts.hasMore, and the archivePath-on-server-vs-sandbox caveat. This is unusually rich behavioral disclosure for a mutation/render 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?

Front-loaded with purpose, then rendering behavior, then input-mode selection, then pagination — a sensible order. A few clauses are UI minutiae ('copy button,' 'Raw/Code toggle') that don't aid invocation, keeping it just short of tight.

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 an 11-parameter, annotation-free tool this covers the risky paths — archive vs explicit files, part-splitting and resumption, ordering, tutor-term matching rules. Remaining gaps (maxTabs interaction with the split, subtitle/intro/contextActions purpose) are covered by the schema, so the omission is minor.

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

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

At 73% schema coverage the baseline is elevated, and the description genuinely adds meaning for the high-stakes params: the part/resume protocol, files ordering and hoisting behavior, and the archivePath machine caveat. It is silent on maxTabs, subtitle, and intro, which are left entirely to 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?

States a specific verb and resource: 'Render a project's source as an interactive card with one tab per file,' then elaborates with syntax highlighting, Raw/Code toggle, and markdown rendering. An agent can immediately tell this is the code-tour card, not the table, chart, or markdown card among its siblings.

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?

Gives explicit selection criteria between the two input modes ('Pass the path of a zip archive generated earlier... or pass files explicitly') and a precise continuation protocol for pagination. It does not name sibling tools as alternatives, so it stops short of full when-not 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, the description carries the full burden and does disclose real behavior: the card renders character/token counts, a copy button, and a send button gated behind a confirmation box, and critically that the tool does not itself act on the prompt. Permission, state, or edge-case behavior (e.g. what happens if prompt is blank beyond minLength) is not covered, keeping it out of 5 territory.

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 flow position and artifact, then the authoring rule, then the do-not-act constraint. Every sentence contributes, though the first sentence is dense with UI feature enumeration that borders on over-specification.

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?

An output schema exists, so return values need no explanation, and the description covers flow position, authoring intent, and the non-action constraint. The only meaningful gap is undocumented title/subtitle parameters, which is a minor incompleteness rather than a blocker.

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 60% with the main required 'prompt' param described in the schema, and the description adds genuinely useful authoring guidance for it (verbose only where verbosity buys a complete first-pass answer, explicit output shape). However, 'title' and 'subtitle' remain undocumented in both schema and description, and 'contextActions' semantics are largely carried by the schema itself, so this sits at the baseline-3 level.

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?

States a specific verb and output artifact: hand back the finished prompt in an editable card with counts, copy and send controls. It also situates itself as step 3 of the efficient-prompt flow, which helps distinguish it from siblings, though it never names the adjacent prompt-card siblings (create_prompt_gist_card, create_prompt_refine_card) so an agent must infer the routing.

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 'Step 3 of the efficient-prompt flow' framing plus the explicit prohibition 'Do not act on the prompt here - wait for the user to send it back as a message' gives clear when-to-use and when-not-to-act guidance. It does not, however, state when to choose this card over the other prompt-card siblings.

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 it does disclose the critical side effect: submitting returns the values to the chat as the next prompt, optionally shaped by promptTemplate. That is the behavior an agent most needs to know for an interactive, non-read-only tool, though it says nothing about blocking, rendering timing, or cancellation.

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 tight sentences with no filler, front-loading the render action and follow-on submit behavior. Every clause 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?

An output schema exists, so return values need not be explained, and the submit-to-prompt flow is covered. Still, a 7-parameter interactive tool with no annotations and only 29% schema coverage leaves the non-promptTemplate parameters (fields, submitLabel, contextActions semantics) under-explained.

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 only 29% across 7 parameters, so the description must compensate. It explains promptTemplate and its {{fieldName}} substitution tokens, which is real added meaning, but title, fields, subtitle, description, submitLabel and contextActions receive no explanation in the description (contextActions is only covered inside 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?

States a specific verb and resource ('Render a form card') and adds the interaction model: the user fills it in to give the conversation context and direction. An agent can distinguish it from the other card creators by the 'form' noun, though the description never explicitly contrasts it with siblings like create_list_card or create_prompt_refine_card.

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 implies the usage context ('to give the conversation context and direction'), which is a genuine hint about when to reach for a form rather than a static card. However, there is no explicit when-to-use/when-not statement and no named alternative among the many sibling card tools, so selection still requires 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?

No annotations are provided, so the description carries the full burden, yet it only describes what the card looks like. It says nothing about the creation/mutation semantics, the interactive tutorTerms and contextActions behavior, or any side effects — all of which matter for a tool that constructs a live card.

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 tight sentences with the core capability front-loaded and the numbering scheme given concretely. 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?

An output schema exists, so return values need not be described, and the two complex params carry rich schema docs. However, with no annotations and no mention of the card's interactive features, the definition is only minimally complete for an agent deciding how to populate 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?

Schema coverage is only 33%, so the description must compensate. It does explain the nested/hierarchical nature that maps to items.children (which itself has no schema description), but it never mentions title, intro, subtitle, tutorTerms, or contextActions, leaving half the parameters to the schema alone.

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?

States a specific verb (Render) and resource (nested ordered list card) plus the distinctive feature (hierarchical numbering 1., 1.1., 1.1.1.). It is clearly distinguishable from sibling card types like create_table_card or create_chart_card, though it never names them 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?

"Good for procedures, outlines, and curricula" gives implied usage context, but there is no explicit when-not guidance and no routing to alternatives (e.g., a flat list or a markdown card). The agent must infer when this card beats its siblings.

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

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

With no annotations provided, the description carries the full burden and does so well: it discloses that raw HTML renders as literal text, that long documents split at H2 boundaries into ~32,000-character parts, how to detect more parts via structuredContent.parts.hasMore, and that documents without H2 headings cannot be split. These are non-obvious behavioral traits an agent would otherwise discover only by trial and error.

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 purpose and rendering behavior are front-loaded, and each subsequent sentence covers a distinct concern (input choice, HTML handling, splitting, no-H2 edge case) with no filler. It is slightly long for a single paragraph but 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 9-parameter tool with no required parameters and an output schema that handles return values, the description covers everything an agent needs: rendering semantics, input source caveats, pagination behavior, and the HTML limitation. Nothing material is left to inference.

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 high (89%), so the baseline is 3 and the description only needs to add marginal value. It does: it explains the interaction between the `part` parameter and the automatic splitting/hasMore flow, and ties H2 folding to splitSections, adding cross-parameter semantics the schema documents only in isolation.

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: 'Render a markdown document as one interactive card', then immediately enumerates the concrete rendering behaviors (tables, code copy buttons, H2 folding). This clearly separates it from siblings like create_table_card or create_code_tour_card, which would render those elements standalone rather than as parts of one markdown document.

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 tells the agent which inputs are acceptable and where content should come from: 'Pass either the markdown content or the path of a markdown file generated earlier in the conversation (for example a walkthrough or guide)'. The schema further warns about the path-vs-sandbox distinction. However, there is no explicit when-to-use-this-vs-a-sibling guidance (e.g. when to prefer create_table_card over a markdown table), which would be needed for 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?

No annotations are provided, so the description carries the full burden, and it does disclose key behavior: submitting the card returns the gist plus the flow rules, and the agent should wait instead of asking follow-ups. It does not cover permissions or error conditions, but for a UI card launcher this is substantial behavioral context.

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

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

Two sentences are used efficiently, front-loading the purpose and flow step before the trigger conditions and behavior. The 350-character detail is embedded usefully, though the sentence is dense with instructions.

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 an output schema present, the description need not explain return values, and it focuses on when and how to call. It is largely complete for a card-launcher tool, though it could better distinguish itself from the similarly named create_efficient_prompt_card sibling.

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 60%, so the schema does most of the work for parameters like question and contextActions. The description adds the 350-character limit and the gist concept, but does not explain the title, subtitle, or placeholder parameters, leaving a moderate gap.

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: opening step 1 of the efficient-prompt flow via a card that asks the user to describe their goal gist. It clarifies the tool's role but does not distinguish it from its close sibling create_efficient_prompt_card, which remains ambiguous.

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

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

It gives explicit triggers (a message tagged [efficient-prompt], or a user asking for help writing a prompt) and even directs the agent to wait rather than follow up in chat. The when-to-use context is complete and actionable.

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 add real behavioral context: default radio widgets, checkbox mode when several answers are true, an always-present free-text 'Other', and a hard cap of 3 refine rounds. It doesn't say what happens to submitted answers or what the card renders/returns, but it discloses enough UI and lifecycle behavior to be usable.

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 tight sentences, front-loaded with the flow position, with no filler. The widget-behavior sentence is dense but each clause carries distinct information; slight trimming of the radios/checkboxes detail is conceivable, but nothing 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?

An output schema exists, so return values need no explanation, and the flow guidance is solid. However, for a 5-parameter tool with a nested `questions` array, several parameters (`title`, `subtitle`, `contextActions`) receive no semantic coverage anywhere, leaving the definition short of 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 40%, so the description must compensate. It explains the `round` semantics ('how many are left') and maps onto the `questions`/`multiple`/`options` structure via the radios-vs-checkboxes and Other rules, but leaves `title`, `subtitle`, and `contextActions` entirely unexplained in both places.

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 gives a specific verb and resource ('ask the fewest multiple-choice questions that close the gaps the gist left') and explicitly positions itself as 'Step 2 of the efficient-prompt flow', which cleanly separates it from the sibling gist and efficient-prompt card tools. An agent can tell what this tool does and where it sits without opening the schema.

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 states clear usage context ('Step 2 of the efficient-prompt flow') and an explicit exclusion ('Skip this step entirely when the gist is already clear enough to write the prompt'), plus the round cap. It stops short of naming the concrete alternative tools (e.g. the gist card as step 1, the efficient-prompt card as step 3), so the routing is implied by flow position rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a real render behavior (source placed in a section's code field becomes a monospace block with a copy button rather than a paragraph), which is useful. However it says nothing about permissions, size/length limits, sanitization of html, or other operational traits an agent would need.

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 tight sentences, front-loaded with what renders first, then use cases, then a practical placement tip. Nothing is wasted, though the final tip is narrow enough that it slightly dilutes the otherwise clean structure.

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?

An output schema exists, so return values need not be explained. The description covers the core capability plus one important param behavior, and the complex tutorTerms/contextActions params are richly documented in the schema. It is largely sufficient, with only sibling-routing detail missing.

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 low (40%) so the description must compensate. It adds meaningful semantics for the code field (monospace rendering plus copy button) versus the text field, partially closing the gap. The remaining params (title, subtitle, and the 'open' behavior behind show-all/hide-all) get no explanation, and tutorTerms/contextActions rely entirely on their schema text.

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?

States a specific verb (Render) and a precise resource (a card of collapsible show/hide sections with show-all/hide-all buttons), which is clearly distinguishable from sibling card types like animation, chart, table, or markdown cards. An agent can identify this tool without opening sibling schemas.

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?

Gives concrete when-to-use guidance ('step-by-step guides, FAQs, spoilers, and long reference material'), which helps selection. It stops short of naming which sibling card to prefer for adjacent scenarios or any exclusion conditions, so it lacks explicit alternative routing.

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 behavioral burden. It discloses useful rendering behavior (interactive tabs, copy button for code, plain text/HTML/code content), but says nothing about persistence, side effects, permissions, size limits, or how tutorTerms/contextActions behave at runtime beyond what the schema already documents.

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 tight sentences, front-loaded with the what and immediately followed by the concrete example and content-type capabilities. No filler, no 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?

An output schema exists, so return format need not be explained, and the rich schema descriptions cover tutorTerms and contextActions. The description sufficiently explains the card's purpose and content model, though it leaves the role of subtitle and the educational/context-action features entirely to the 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?

Top-level schema coverage is only 40% (title and subtitle undocumented in schema), and the description partially compensates by describing tab content types (text/HTML/code-with-copy-button), which maps to the tab item properties. However, it adds nothing about title, subtitle, or how tutorTerms/contextActions interact with the rendered card beyond what the schema already says. Baseline 3 for low coverage with partial compensation.

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?

States a specific verb ('Render') and resource ('interactive card with tabs') and explains the organizing concept: one tab per context of the same subject. It is distinguishable in substance from card siblings like create_chart_card or create_markdown_card, though it never explicitly names or contrasts them.

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 example ('one tab per programming language, OS, or skill level') implies the use case and content-type fit, but there is no explicit when-to-use guidance, no conditions for choosing this over create_code_tour_card or create_markdown_card, and no prerequisites 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?

With no annotations, the description carries the full burden and does disclose real behavior: delimiter auto-detection, newlines as cell markers, and URL cells becoming links. However it is silent on the other high-impact behaviors that only the schema hints at (linkColumns, cellDelimiter override, tutorTerms underlining, contextActions, the 12-column cap), so coverage is partial.

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 compact sentences, front-loaded with the primary action, no filler. Every clause carries information (input modes, delimiter detection, newline cells, URL linking).

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?

An output schema exists so return values need not be described, but for an 11-parameter tool with no annotations the description omits several non-obvious parameters (tutorTerms, contextActions, linkColumns) and never signals the non-destructive nature of the operation.

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

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

Schema coverage is only 45%, so the description must compensate; it clarifies rows, text, delimiter auto-detection, and newline handling, but leaves title, caption, subtitle, columns, headers, linkColumns, tutorTerms, and contextActions unaddressed in prose. Partial compensation over an incomplete 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?

States a specific verb ('Render') and resource ('HTML table card') and enumerates both input modes: explicit rows vs. converting loosely delimited text. The 'table card' resource is clearly distinguishable from sibling card tools like create_list_card and create_chart_card even though no sibling is named.

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 which of the two main inputs to supply ('from explicit rows, or convert ... text'), which is useful conditional guidance, but it never states when to choose a table card over alternatives such as create_list_card or create_markdown_card, and gives no prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the burden, and it does well: it discloses a hard validation rule (platform page URLs rejected), the accepted source forms, and the rationale (a video element on a player page can never play). It does not cover auth/permission needs or persistence, but the failure-mode disclosure is substantive.

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 core purpose, then the constraint, then the fallback. No filler; 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?

An output schema exists, so return values need not be explained. The description covers the decisive routing constraint and the fallback path, leaving only secondary parameter behavior to the schema, which is acceptable for a card renderer.

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 44% (<50%), so the description must compensate. It adds strong meaning for the critical 'src' parameter (accepted formats mp4/webm, http(s)/data:/blob:, rejected platforms) but says nothing about loop, muted, poster, autoplay, subtitle, or contextActions, leaving most parameters to the sparse 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?

States a specific verb ('Render a card') plus resource ('HTML video player for a short clip') and implicitly separates itself from the sibling create_animation_card. An agent can distinguish this from other card-creation tools immediately.

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 states when to use it (direct video file sources), when NOT to use it (streaming platform page URLs are REJECTED), and names the alternative (create_animation_card) with the condition that selects 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?

The description discloses that the tool returns structured data fields (title, headings, tables, etc.), which gives some behavioral insight. It does not mention failure modes, rate limits, authentication needs, or what happens with inaccessible pages, and annotations are absent.

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, with the action stated first and the output details and downstream usage mentioned efficiently. No redundant or verbose 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?

The description gives a clear high-level purpose and output format, and it hints at downstream integration. However, it lacks details about constraints on input, error behavior, or the depth of the structured extraction, leaving some contextual gaps for an agent deciding whether 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 schema provides no per-parameter descriptions. The description mentions 'maxTextChars' indirectly through the structured data output, but it does not explain the meaning of the parameter, its unit, or the effect of the minimum/maximum constraints. The 'url' parameter is obvious from context but not formally described.

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 the specific action 'Fetch a public web page' and distinguishes the tool from siblings by explaining that results feed into card tools. It does not explicitly name sibling tools it differs from, but the downstream use case clarifies its role.

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 needing structured web content for card creation—but does not explicitly state when not to use it or how it compares to alternatives like read_local_file. The 'and so on' phrase is vague about the full range of downstream tools.

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

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

No annotations are provided, so the description carries the full burden. It thoroughly discloses the bookmarklet's behavior: insertion is cosmetic, page-local, gone on reload, and not part of conversation history. It also clarifies the prerequisite step (copying a card) and the mechanism (right-click menu). This is exemplary 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 a single, dense sentence that front-loads the purpose, then explains the mechanism and context. Every clause earns its place, providing essential context without redundancy.

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

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

The tool has no output schema, but the description fully covers what the agent needs: what the tool returns, when to call it, why it's needed, and the behavior of the result. There are no gaps for a 0-parameter retrieval 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 is 4. The description adds context about the tool's invocation but not parameter semantics since there are none. This matches the rubric for a 0-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 clearly states the tool's purpose: to return the Insert Card bookmarklet and usage instructions. It explicitly names the verb 'Return' and the resource 'bookmarklet', and distinguishes it from sibling tools (which create cards or handle files) by explaining the specific scenario it addresses.

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 explicit usage guidance: 'Call this when the user asks how to place a card at an arbitrary spot on the page.' It also explains the underlying context (browser limitation) and why the bookmarklet is needed, leaving no ambiguity about when to invoke 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, the description carries the full behavioral burden and does disclose a genuinely non-obvious trait: the card is interactive, and on submit the values return to the chat as a structured payload routed to submit_web_form. The word "public" implicitly flags that no authentication is available. It does not cover failure modes (JS-rendered forms, unreachable pages) or any rate limiting.

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 filler, with the core action stated first and the downstream handoff second. Every clause adds information the agent 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?

An output schema exists, so return-value explanation is rightly omitted, and the description supplies the workflow context an unannotated tool needs. Minor gaps remain around error behavior and whether non-public or login-gated pages are rejected, but nothing essential to a correct call is missing.

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 67% with url fully specified as a URI, and title/formIndex already documented in the schema. The description adds only marginal semantics — "public web page" constrains url, and "one of its forms" loosely maps to formIndex, but it never mentions the title override. Roughly baseline for partially-covered 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 gives a precise verb chain — fetch a public page, extract one of its forms, render it as an interactive card — which is clearly distinct from sibling tools like create_form_card (builds a card from scratch) and fetch_reference (plain fetch). It even names submit_web_form as the downstream consumer, so the agent can place this tool in the workflow without opening another schema.

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 use case is explicit: mirror a real website's form so a model-created task can submit it. The description explains the full round trip, ending with submit_web_form. It falls short of naming when *not* to use it (e.g., versus fetch_reference or create_form_card for non-web forms), which keeps it out of the top band.

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

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

With no annotations provided, the description carries the full burden. It discloses size caps, binary refusal, and filesystem confinement, which are critical behavioral traits. It doesn't detail error handling or exact return format, but the key constraints are well covered.

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 each sentence adding value: purpose, remote bridge caveat, size/binary limits, and configuration. It's front-loaded with the core purpose and efficiently covers all key points without 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 tool with two parameters and no output schema, the description covers purpose, constraints, and configuration. It lacks explicit return format details, but given the tool's simplicity and the absence of an output schema, the description is largely sufficient for an agent to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains the 'path' parameter's context (server filesystem) and implies 'maxChars' via size caps, though it doesn't explicitly name maxChars. The description adds meaning beyond the bare schema, but could be more explicit about maxChars.

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 reads a text file from the server's filesystem for review and card integration. It distinguishes itself from siblings by focusing on local file access, which is unique among the listed card creation and web 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?

It explicitly warns about remote bridge scenarios, advising to pass text directly to the card tool instead. It also mentions size caps and binary refusal, and provides configuration guidance via MCP_CHAT_CARDS_FS_ROOT, giving clear when-to-use and when-not-to-use context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action (submit values), the encoding, and the return (HTTP status and snippet). However, it does not disclose potential side effects (e.g., submitting data could mutate server state) or mention authorization, rate limiting, or failure behavior. The clause 'real website form' hints at an actual external action, but more explicit disclosure would be safer for an agent. The constraint on when to call it is a good behavioral trait.

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

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

The description is a single sentence that front-loads the purpose and includes the usage constraint and return format. It is concise with no filler. The critical usage condition is placed early, making it easy for an agent to parse. Slightly more structure (e.g., separating the return statement) could improve readability, but as is, it is efficient.

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 four parameters, two of which are nested objects, and no output schema, so the description must cover operational context. It states what it does, when to call it, and what it returns. However, it lacks guidance on error handling, side effects, or details about the structure of 'fields' and 'headers' beyond schema descriptions. Given the absence of annotations, an agent would benefit from explicit notes about the potential mutating nature of submitting a form. It is adequate but not comprehensive.

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 descriptions for 'action' and 'fields' but not for 'method' or 'headers' (50% coverage). The description adds 'form-encoded GET or POST,' which clarifies the method parameter's purpose and its encoding format. However, it does not add meaning for 'headers' or provide additional detail on how 'fields' should be structured beyond the schema. Since the schema already documents half the parameters and the description clarifies method encoding, it meets the baseline but does not fully compensate for the undocumented 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 clearly states the verb 'Submit' and the resource 'a real website form,' and specifies the encoding ('form-encoded GET or POST'). It distinguishes itself from the sibling card-creation tools by emphasizing this is an actual submission, and the reference to 'mirrored form card' implicitly connects it to mirror_web_form. Specific and unambiguous.

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

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

The description gives a clear condition for use: 'Only call this with data the user entered in a mirrored form card, or values the user explicitly confirmed.' This provides a strong guardrail. It doesn't explicitly name alternatives or say when not to use it, but the constraint implies it should be used only after mirror_web_form and with user consent. Evidence: 'Only call this...'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well: it explains that the path is resolved on the server machine, not in the caller's sandbox, and that build caches and binary entries are skipped. It does not mention permissions, rate limits, or whether anything is written to disk, but the core behaviors are covered.

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, all carrying substantive information. The main behavior is stated first, followed by the important environment safety note and the skip policy. No filler or repetition.

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 sufficiently complete for a moderately simple tool: it defines the operation, the environment constraint, and the filtering behavior. No output schema exists, but because the description says 'return the contents of its text files', the return concept is explained reasonably. It does not specify the output format or potential edge cases, but these are minor gaps.

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

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

Schema description coverage is low (33%), but the description adds critical semantics for the required 'path' parameter by emphasizing server-side resolution. The 'include' parameter already has a schema description; maxFiles only has numeric bounds, but the tool's purpose implies it limits the number of inspected files. The description partially compensates but does not fully document all 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 states a specific verb and resource: 'List a zip archive's entries and return the contents of its text files.' This is unambiguous and clearly distinguishes the tool from siblings like read_local_file by describing a zip-inspection workflow.

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 described use case—'so a project can be inspected and turned into cards'—gives clear context for when to call this tool. It does not explicitly name alternative tools or state when not to use it, but the purpose is obvious enough for an agent to choose it appropriately.

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