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

With no annotations, the description carries the full burden (baseline 3). It goes beyond by disclosing: scenes play sequentially in a 16:9 stage with controls, everything is procedurally generated (text, SVG shapes, CSS animation) with no external assets, and shows how to handle variations via per-scene transitions/durations. It misses some edge cases (e.g., what happens if scenes is empty – though schema enforces minItems 1), but the disclosed behavioral traits are rich and accurate.

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 substantial but every sentence earns its place, covering what, why, and how to compose scenes. It could arguably be front-loaded more (the key 'when to use' is first, which is good). Minor deduction for density - an agent might need to parse carefully - but no fluff.

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

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

Given the tool's complexity (nested scenes, transitions, shapes, charts) and the rich schema, the description does an excellent job of tying it together. It explains the animation model (sequential scenes, transitions), provides patterns (title reveal, chart zoom), and even implies limits (no external assets means you can't rely on images). Not a 5 because it doesn't explicitly document error cases or fallbacks, but for the complexity it covers the essentials well.

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%, so the schema itself documents most parameters. The description adds value by implying how scenes (structure of shapes, bullets, chart) relate to the animation, and clarifies the 'no external assets' constraint that affects how to fill scene content. However, it does not directly explain the semantics of properties like durationMs, loop, or autoplay beyond what the schema already states, so it doesn't fully bridge the 37% 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 uses a specific verb ('Render'), identifies the resource (a short animated clip as a card), and clearly distinguishes when to use it: when no direct video URL exists but motion would communicate better. It also differentiates from siblings like create_video_card by emphasizing generated content (text, SVG, CSS) over external assets, which is a strong differentiator visible in the sibling list.

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 first sentence explicitly states the primary use case and contrasts with the alternative ('when no direct video URL exists'). It also gives composition guidance ('Compose classic clip patterns and vary them per conversation') and lists concrete examples that heavily imply when to use this over a static card. While it doesn't name a specific sibling, the 'no direct video URL' contrast with create_video_card is an explicit exclusion condition.

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 transparency burden. It discloses the output behavior (SVG chart, legend, collapsible data table) but does not explicitly state that this is a mutating operation inserting a card into the host UI, nor any side effects. This is partial transparency, so a middle score is appropriate.

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 short sentences front-load the action and output, list chart types, and add a use case without repetition or filler. Every phrase 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 10-parameter tool with an output schema and no annotations, the description plus the rich schema is nearly sufficient: required inputs are trivial, the data-parameter schemas are described, and the use case is stated. Minor omissions like explicit chart-type selection guidance prevent a 5.

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 50%, so the baseline is 3. The description adds no parameter-level guidance, but the schema already describes labels, series, values, tutorTerms, and contextActions; remaining params like title, type, and subtitle are semantically obvious. The description does not undersell the 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 names a specific action ('Render'), a concrete resource ('SVG chart card'), and enumerates the supported chart types (bar, line, pie, donut). It clearly differentiates this tool from the table, list, and markdown card siblings by focusing on chart rendering with a legend and collapsible data table.

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 sentence 'Use for useful graphics summarizing referenced data' provides a clear, actionable context for when to invoke the tool. It does not explicitly name alternatives or exclusions, but the context is specific enough to route an agent toward this card type over table/list/markdown 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 zero annotations, the description carries the full disclosure burden and meets it thoroughly. It reveals the surprising behaviors an agent must know: files split into ~32,000-character parts regardless of count, README/manifests are hoisted, ordering differs for archives vs explicit files, unknown languages degrade to plain code blocks, and the hasMore loop may withhold files. This is exactly the kind of non-obvious behavior that prevents incorrect 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 long (~300 words) but earnestly dense: each clause conveys a behavioral fact — rendering features, markdown special-casing, file ordering, splitting, pagination — and there is no filler. It is front-loaded with the core purpose before the detail. The only structural weakness is that it is one undifferentiated block; paragraph breaks at the markdown, ordering, and pagination transitions would improve scanability.

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, zero-annotation tool with a rich output schema, the description is remarkably complete. It covers the rendering contract, the markdown exception, ordering semantics, both invocation modes, the splitting mechanism, and the paging loop tied to structuredContent.parts. The output schema already documents return shape, so the description needn't repeat it. Nothing an agent needs to call this correctly across multipart tours 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 description coverage is 73%, so the schema already documents most parameters well. The description adds genuine value beyond it: it clarifies the archivePath-vs-files choice ('Pass the path of a zip archive generated earlier in the conversation'), quantifies the part size (~32,000 rendered characters), and adds the 'identical other arguments' constraint for pagination. The few schema-undocumented fields (subtitle, title, path/content/language inside file objects) are self-evident from their names, so the gap is acceptable.

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 states a specific verb and resource: 'Render a project's source as an interactive card with one tab per file.' It then enumerates concrete rendering features (syntax highlighting, line numbers, Raw/Code toggle, copy button) that make the tool unmistakable against the sibling card-creation tools. The markdown-handling special case further narrows the identity — this is clearly the source-code card, not a generic tab or markdown 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?

The description gives explicit invocation guidance: pass a zip archive path for a 'one-call plug-n-play tour' or pass files explicitly, and it specifies the pagination protocol ('while hasMore is true ... call again with part: current + 1 and identical other arguments'). This is strong operational guidance. However, it never names sibling tools or states when NOT to use this tool (e.g., when a plain markdown card would suffice), so exclusions 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 full behavioral burden and delivers: it discloses the deliver-only behavior ('Do not act on the prompt here'), the card's UI behaviors (copy button, confirmation-gated send), and the content-quality bar for the prompt (no filler, explicit output shape). No contradictions between description and the absent annotations. Loses a point only because it doesn't describe side effects such as what happens once the user confirms the send.

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 sentences, each earning its place: the first front-loads the purpose and UI format, the second sets the prompt-quality standard, and the third guards against a common misuse. No filler, no 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?

Given an output schema exists and the schema covers the required prompt plus notes and contextActions, the description fills the key gaps: workflow position, deliverable format, and the critical non-execution guardrail. Title and subtitle semantics are the only unaddressed gap, and they are low-ambiguity in a card context.

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

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

Schema coverage is 60%, with prompt, notes, and contextActions already documented in the schema. The description adds only implicit meaning — that 'prompt' is the finished deliverable — and says nothing to clarify the undocumented title and subtitle parameters. The UI details (character/token count, copy button) describe the card itself, not how the parameters map to it.

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: 'hand back the finished prompt in an editable card' with concrete UI elements (character/token count, copy button, confirmation-gated send button). Positions itself as 'Step 3 of the efficient-prompt flow', distinguishing it from sibling card tools like create_prompt_refine_card and create_prompt_gist_card. The title 'Deliver the efficient prompt' reinforces the resource being delivered.

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?

Places the tool explicitly in a workflow ('Step 3 of the efficient-prompt flow'), giving clear context for when to invoke it. Adds an explicit exclusion: 'Do not act on the prompt here - wait for the user to send it back as a message,' which prevents premature execution. Stops short of naming the sibling tools that cover the other steps, so alternative routing is implied rather than 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 provided, the description carries the full behavioral burden and delivers the critical trait: submission sends values back to the chat as the next prompt, optionally shaped by promptTemplate with {{fieldName}} tokens. This discloses the non-obvious side effect (values become a user message, not a tool result). Minor traits like required-field validation blocking submission are not covered, but the essential model 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?

Two sentences with zero filler: the render action leads, and the submission mechanism follows directly. Every clause earns its place, including the optional promptTemplate note.

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 UI tool with no annotations and an existing output schema, the description covers the essential end-to-end flow: render, user fills, values become the next prompt. The contextActions behavior is already documented in the schema, and the output schema covers return values. The only gap is validation behavior for required fields, which is a minor omission for an interactive 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 low (29%), and the description compensates for the most important semantics — fields' values round-trip into the conversation, and promptTemplate token substitution shapes the prompt. However, it adds no meaning for title, subtitle, description, or submitLabel, relying on their self-explanatory names rather than explaining their presentation role.

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

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

The description uses a specific verb ('Render') with a concrete resource ('a form card') and states its purpose ('to give the conversation context and direction'). The second sentence adds the defining behavior — submitted values return as the next prompt — which distinguishes it from sibling card creators. It doesn't explicitly name a sibling, but the interaction model is specific enough to select correctly.

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 use case: render an interactive form when the conversation needs structured context or direction from the user. However, it offers no explicit when-not-to-use guidance or alternatives, and with siblings like mirror_web_form and submit_web_form also handling form-like input, a sentence routing the agent would materially help.

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 disclosure burden. It does disclose the core rendering behavior: nested ordered list with hierarchical numbering. But it does not mention notable interactive behaviors like tutorTerms underlining/hover or contextActions, which are only described in the schema.

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

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

The description is two sentences with no filler. It front-loads the operation and output format, then adds a practical usage note. 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 an output schema, the description does not need to explain return values. The core usage is covered, and the more complex optional parameters (`tutorTerms`, `contextActions`) are documented in the schema. Some gaps remain around optional parameters and sibling differentiation, but overall the definition is reasonably 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 only 33%, and the tool description does not compensate. It hints at the nested `items` structure through 'nested ordered list card', but it does not explain `title`, `intro`, `subtitle`, or how nesting maps to `children`. Only `tutorTerms` and `contextActions` have schema-level descriptions.

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

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

The description states a specific verb ('Render') and a specific resource ('nested ordered list card') with distinctive behavior (hierarchical numbering). It is clear about what the tool produces, though it does not explicitly distinguish it from sibling card tools by name.

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 phrase 'Good for procedures, outlines, and curricula' gives useful intended-use context. However, it does not explain when to choose this over alternatives such as create_markdown_card or create_table_card, nor does it mention any 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 full responsibility for behavioral disclosure, and it delivers. It explicitly warns that raw HTML is shown as literal text, explains that long documents split at H2 boundaries into ~32,000-character parts, and tells the caller how to detect remaining parts via structuredContent.parts. This goes well beyond the title and gives the agent actionable expectations about side effects and output.

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 dense but efficient: a concrete first sentence, input options, one important formatting caveat, and a clear explanation of splitting behavior. No sentence is wasted, and the most important behavioral facts are 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?

The description covers the tool's rendering behavior, input alternatives, the raw-HTML limitation, split behavior, and how to check for remaining parts. Given the rich input schema and presence of an output schema, an agent has enough context to select and invoke this tool correctly.

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

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

Schema description coverage is high (89%), so the schema already documents most parameters. The description adds valuable semantics by explaining the either-or relationship between markdown and path, the splitting behavior tied to part, and the constraint that path refers to the machine running the server. This supplements rather than merely restates the schema.

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

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

The description opens with a specific verb and resource: 'Render a markdown document as one interactive card.' It then lists concrete affordances (tables become card tables, code gets copy buttons, H2 sections fold into reveals) that make the tool's purpose unmistakable. It also distinguishes it from sibling card creators by tying it to markdown input.

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

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

The description clearly communicates when to use the tool: pass either markdown content or a previously generated markdown file. It also gives practical guidance about using markdown syntax because raw HTML is not rendered. It does not explicitly name alternative card-creation tools, but the input source and rendering behavior make the intended use 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 behavioral burden, and it does well: it explains this is step 1, that submitting sends back the gist plus rules, and instructs the agent to answer with the card and wait. It could add detail on what the resulting card contains visually or how the next flow step is triggered, but the core behavior is disclosed.

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 with a distinct job: what the tool does, when to call it, and how to behave after calling it. The description is front-loaded with the action and contains 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 simple card-generation tool with an output schema, the description covers the key context: flow position, trigger conditions, character limit, and follow-up behavior. It leaves the relationship to create_efficient_prompt_card and create_prompt_refine_card implicit, which is the main completeness 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 coverage is 60%, with question, placeholder, and contextActions documented. The description adds flow context but does not explain the remaining title and subtitle parameters or map them to behavior. It is adequate because the purpose of the card clarifies why fields exist, but there is a clear gap for 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 uses a specific verb and resource: 'Open step 1 of the efficient-prompt flow' and a card asking for the gist in no more than 350 characters. This clearly identifies the tool as the entry point of the prompt flow and distinguishes it from later flow steps and sibling card 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 states explicit triggers: 'when a message is tagged [efficient-prompt], or when the user asks for help writing a prompt.' It gives behavioral instructions to use the card and wait, but does not explicitly contrast this tool with close siblings such as create_prompt_refine_card or create_efficient_prompt_card, so it stops short of full 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 behavioral burden, and it handles it well: it discloses the multiple-choice format, radio/checkbox behavior, free-text 'Other', the 3-round limit, and the need to pass the round number. It omits details about return values or side effects, but the output schema exists and these are card-creation semantics.

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 tight sentences with the core purpose first, followed by concrete behavioral details and the skip rule. There is no filler or redundancy.

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

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

The description plus schema give enough for an agent to decide and call the tool: flow position, round bounds, skip condition, and question format. It references 'gist' without defining it, but that term is established by the sibling flow. Since an output schema exists, omitting return-value details is acceptable.

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

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

Schema description coverage is only 40%, so the description should compensate. It adds useful meaning to 'round' and implies the effect of 'multiple' through checkboxes, but it does not explain title, subtitle, questions structure, or contextActions, leaving those to the schema. The nested schema descriptions help, but the compensation is partial.

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 role: 'Step 2 of the efficient-prompt flow: ask the fewest multiple-choice questions that close the gaps the gist left.' This places it distinctly among siblings like create_prompt_gist_card and create_efficient_prompt_card. It is clear the tool produces a refine card, further confirmed by 'so the card can say how many are left.'

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 explains when to use it ('Step 2 of the efficient-prompt flow') and when not to ('Skip this step entirely when the gist is already clear enough'). It does not name alternative tools to use in the skip case, but the flow context makes the alternative implicit.

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

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

The description explains rendering details: code fields become monospace blocks with a copy button, tutor terms render as underlined micro-tips with longest-first matching and case-sensitivity. No annotations provided, so the description carries the burden and does it well. It could mention more about interactions beyond the described behaviors, but it's solid.

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?

Description is focused and dense, listing use cases and key behavior without verbose filler. The tutorTerms description is long but necessarily detailed for precise matching semantics.

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?

Covers what the card does, when to use it, and rendering details. Lacks explicit when-not-to-use and alternatives, but with no annotations and a complex schema, it's adequately complete for an agent to select and invoke correctly.

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

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

The schema covers parameter types and minItems, and the description adds meaning: code renders as monospace with copy button, text is plain, tutorTerms matching rules. Some params like subtitle and open are left plain, but overall usage is clear.

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 deliverable — a card of collapsible show/hide sections with show-all/hide-all buttons — and lists concrete use cases (step-by-step guides, FAQs, spoilers, long reference material). This makes the tool's purpose unambiguous and distinct from typical siblings like tab or code-tour cards.

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

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

It explicitly says it's good for step-by-step guides, FAQs, spoilers, and long reference material, which gives clear usage context. It does not name alternatives or state when NOT to use it, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that the card is interactive, tabbed, and supports plain text, HTML, and code with a copy button. It does not mention behaviors like HTML sanitization or tutor-term hover interactions, though those are already documented in the schema fields, so the gap is moderate rather than severe.

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

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

The description is a single well-structured sentence that front-loads the core operation, then provides concrete examples and content-type options. Every phrase earns its place and there is no filler or repetition of schema details.

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

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

The tool's core purpose is clearly explained, and the schema richly documents the optional tutorTerms and contextActions behaviors, while an output schema is present. The main missing piece is explicit guidance on when to prefer this over sibling card tools, but for a card-rendering tool with modest complexity this is adequately complete.

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

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

Schema description coverage is only 40%, so the description should compensate for undocumented parameters. It adds useful semantics for the core 'tabs' parameter: tabs are different contexts of the same subject and can hold text, HTML, or code. However, it does not add meaning for title, subtitle, tutorTerms, or contextActions beyond what the schema already documents, so compensation is partial.

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

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

The description uses a specific verb ('Render') and resource ('interactive card with tabs'), and explains the organizing principle: tabs show different contexts of the same subject with examples like programming language, OS, or skill level. This clearly distinguishes it from sibling card tools such as create_table_card, create_chart_card, or create_video_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?

The description provides clear context for when this card is appropriate: when the user needs multiple perspectives on the same subject, e.g., one tab per language or OS. It does not explicitly name alternatives or state when not to use it, but the use case is specific enough for an agent to route correctly.

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 bears the full burden for behavior. It discloses useful behaviors: delimiter auto-detection, newlines as optional cell markers, and URL cells becoming links. It also implies a balanced table normalization. Yet it does not mention behavior for when both rows and text are supplied, or any failure modes, making it sufficient but not rich.

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

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

The description is two sentences, front-loaded with the core purpose and then adds a single behavioral detail (URL links). It is efficient, with no redundant fluff, and every clause adds a distinct use-case or behavior. This is an example of concise, high-value prose.

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 11 parameters and one required field (title), the description covers two main input modes but does not touch on caption, subtitle, columns, headers, tutorTerms, contextActions, or linkColumns. Though output schema exists, the set of options is broad, and many are left to the schema's implicit meaning. For an agent to use all features correctly, more explanation would be needed, but it suffices for the common path.

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 45%, and several parameters (columns, caption, subtitle, linkColumns, cellDelimiter) lack inline descriptions. The description adds meaning for text and cellDelimiter (auto-detected) and linkColumns (URL cells become links), but it ignores caption, columns, subtitle, and headers beyond what is in the schema. It compensates for some gaps but not the majority, so it meets the minimum but not more.

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: 'Render an HTML table card from explicit rows, or convert loosely delimited text into a balanced table.' This is a specific verb plus resource, making it distinct from sibling creation tools like create_chart_card or create_form_card. The two modes (explicit rows vs. text) are named, adding specificity, though it doesn't explicitly name a different sibling or exclusion.

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 two main use cases (structured rows or raw text conversion) and mentions auto-detection of delimiters, which gives some guidance. However, it does not explicitly state when to favor this over sibling card creators (e.g., for tabular data vs. charts) or provide any 'when not to use' guidance. Since siblings are numerous, a clearer routing could be expected, but the core instruction ('from explicit rows or text') is implied enough for basic use.

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 were provided, so the description carries the transparency burden. It explains why streaming pages fail (video element pointed at a player page), which is useful behavioral context蓬莱. However, it doesn't mention the output/card format, side effects, or limits on file size. The main behavioral constraint (source type) is well-covered, but other runtime behavior is not described.

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. The first immediately states the action and the key constraint. The second explains the rejection rule and points to the alternatve tool. No wasted words.

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

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

The description covers the essential constraint on src, which is the most error-prone parameter, and named the sibling tool for animations. It doesn't describe the return value, but an output schema exists. Minor gap: no mention of required vs optional fields like title, but the schema lists required. Good overall.

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 explains 5 of 9 parameters (src, poster, autoplay, contextActions; loop and muted have only type). The description adds critical detail for src (direct video file only, reject streaming URLs) and ties to the card rendering. That compensates for the low schema coverage on the most important param, but the others remain thin. A middle score is fair.

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 precise verb and resource: 'Render a card with an HTML video player for a short clip.' It immediately distinguishes the tool from siblings by specifying the target format (video file) and the explicit exclusion of streaming-platform URLs, making the purpose unambiguous.

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

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

It states the hard constraint: src must be a direct video file, and explicitly lists what is rejected (streaming URLs) with the reasoning. It also names the alternative tool (create_animation_card) and the condition for using it, so an agent can classify inputs correctly.

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 behavioral burden and does reasonably well: it discloses the side effects (fetching, extracting, rendering, returning a structured payload on submission) and a limitation ('public web page'). It omits details like rate limits, failure behavior, or handling of pages without forms, but the core workflow 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?

The description is compact and well-ordered: action, object, output flow, and downstream purpose. Every clause contributes indispensable information, with no filler or redundantly repeated schema details.

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

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

Given the tool's complexity and the absence of annotations, the description gives the agent a complete mental model of the execute-and-submit loop, and the presence of an output schema covers return details. It remains slightly thin on edge cases like 'page has no forms' or 'multiple matching forms,' but it is still sufficiently complete for correct tool selection and invocation.

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

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

The schema already documents title and formIndex, and the description adds some contextual meaning—especially that the URL must point to a public page and that a single form is extracted. However, it mostly relies on the schema for parameter specifics rather than enriching them, so the added value is moderate.

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-resource pair: fetch a public web page, extract one of its forms, and render it as an interactive card. It also distinguishes itself from the sibling submit_web_form tool by describing how the card payload feeds into that separate submission step.

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

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

The description clearly conveys when to use the tool: when a website form should be mirrored into the conversation so a model-created task can later submit it. It even names the follow-up tool (submit_web_form), which gives strong routing context, though it does not explicitly state exclusions such as 'use create_form_card for manually built forms.'

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.