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

With no annotations, the description must carry disclosure, and it does state the graceful termination behavior, the Windows scope, and that omitting pid closes all Typora processes. However, it does not explain consequences for unsaved work, whether 'graceful' vs 'kill' differs, or what the tool returns, leaving a partial transparency gap.

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

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

One sentence front-loads the primary action and then states the pid variant, with no filler. 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?

For a simple one-parameter tool with no output schema, the description covers the action, platform, and pid-omitted behavior necessary to invoke it correctly. It omits optional caveats like unsaved-change handling, but the core call contract is sufficiently complete.

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

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

The input schema already documents pid as optional and the omitted-pid behavior, so description adds no new parameter semantics beyond restating 'specific process ID' and 'by process ID.' With 100% schema coverage, baseline 3 is appropriate.

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

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

States a specific verb-resource pair ('Gracefully terminate running Typora processes on Windows') and adds the pid-targeting mode, clearly distinguishing it from siblings like typora_open and typora_status.

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?

Usage is implied by the verb and scope, but the description never names alternatives or says when not to use it. It lacks explicit routing vis-à-vis typora_status or typora_open.

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 that this is a write operation that also launches the Typora application ('immediately open it'), and it clarifies how the optional title is formatted (as H1 in the schema). It does not mention overwrite behavior or error handling, but the main side effect and structure are stated.

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

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

One compact sentence that front-loads the core action and the optional components. No filler or redundancy—every clause adds information about what the tool does and what it produces.

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 key outcome (file creation and opening) and the optional parameters, and there is no output schema to explain. However, it omits handling of edge cases such as whether existing files are overwritten or whether parent directories are created, which are relevant for a file-creation tool. For a straightforward create-and-open operation, this is acceptable but not exhaustive.

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

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

Schema coverage is 100%, so the baseline of 3 applies. The description merely lists the parameters ('title, YAML frontmatter, and body text') without adding meaning beyond the schema, which already documents each field including the H1 formatting and frontmatter key-value pairs.

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 ('Create') with a concrete resource ('Markdown file') and specifies the optional components (title, YAML frontmatter, body text) plus the immediate side effect of opening in Typora. This clearly differentiates it from siblings like typora_open (which opens existing files) and typora_list_drafts (which lists files).

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

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

The intended use is reasonably implied: use this when you need a new Markdown file that should also be opened. However, the description does not explicitly state when not to use it or mention the alternative typora_open for existing files, so the routing decision is left to the agent's 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 of behavioral disclosure. It does add value by explicitly saying 'Read' and naming the data source (profile.data) and specific fields, but it does not mention side effects (though read is implied), failure behavior, or whether the output is a full raw config snapshot versus a filtered subset.

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?

A single, well-constructed sentence that front-loads the action and resource, then efficiently lists the notable preference categories. Every phrase contributes information; there is 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?

With no parameterslint, no output schema, and no annotations, the description adequately explains what the tool does and what to expect. It could theoretically mention the return format (e.g., JSON) or note that it returns all preferences, but the listed examples give sufficient context 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?

The tool has zero parameters)Skip{...}, so the input schema fully covers invocation needs. The description adds semantic context about what the returned configuration contains, which is meaningfully informative even though no parameters exist.

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

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

States a specific verb ('Read'), a clear resource ('Typora's configuration and user preferences (profile.data)'), and enumerates the exact preference groups it covers. This unambiguously distinguishes it from siblings like typora_list_themes or typora_get_theme_css, which target narrower theme-specific data.

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

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

No guidance is given about when to use this tool versus alternatives such as typora_status, typora_list_themes, or typora_get_preferences. The description implies a general config-reading purpose but offers no explicit conditions, 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 of conveying behavior. It signals a non-destructive read operation and notes the theme must be installed, but it does not disclose behavior for invalid theme names, missing themes, or whether the CSS is returned raw/unmodified. For a simple read tool this is adequate 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 a single sentence with no filler, front-loading the action and resource while using parenthetical examples efficiently. Every word contributes to understanding.

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

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

For a one-parameter read tool, the description plus schema provides enough to invoke the tool correctly: pass a theme name, with or without extension, and receive raw CSS. The only minor gap is the lack of explicit guidance about error handling or behavior for an uninstalled theme, which would make it fully complete.

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

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

The input schema already documents the single required parameter, including the useful detail that the .css extension is optional. The description's example theme names add flavor but not additional semantic meaning, so with 100% schema coverage the baseline of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: retrieve the raw CSS styling for an installed Typora theme. It also lists concrete theme examples, which makes the tool's scope immediately understandable and distinguishes it from sibling tools like list_themes, set_theme, and install_theme.

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 makes the intended context clear—fetching raw CSS for an installed theme—and this is clearly distinct from the sibling tools. However, it does not explicitly name alternatives or provide when-not-to-use guidance, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly indicates a persistent filesystem write to the theme directory and the install-or-update nature of the operation, plus the resulting menu visibility. It stops short of explicitly warning that a same-named existing theme will be overwritten, but 'update' makes that behavior reasonably clear.

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

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

A single sentence that front-loads the action ('Install or update'), then gives the destination and outcome with no filler. It avoids repeating parameter names or schema content.

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

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

For a two-parameter filesystem-write tool with no output schema, the description conveys enough about side effects and expected results. It would be slightly stronger with an explicit note that installing a theme with an existing name overwrites it, but the operation is simple and the description is functionally adequate.

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?

Both parameters are fully described in the input schema, so the description does not need to re-explain them. The description adds useful context about the target directory and the menu-visible outcome, but it provides no additional meaning about accepted name formats or CSS content constraints beyond what the schema already defines.

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 precise verb ('install or update'), a specific artifact ('custom CSS theme'), a destination ('%APPDATA%\Typora\themes'), and an observable outcome ('appears in Typora's Theme menu'). This clearly differentiates it from sibling tools like typora_set_theme, which applies a theme rather than installing it.

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 implicitly communicates when to use the tool: when you have raw CSS and want a new or updated theme to appear in Typora's Theme menu. However, it does not explicitly contrast this with sibling tools such as typora_set_theme or typora_list_themes, so the usage boundary is 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It clarifies the source directory and implies a read-only listing operation, but it does not explicitly state that nothing is modified, how results are ordered, or what information about each backup is returned.

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?

A single, front-loaded sentence with no filler. It states the action, the resource, and the relevant directory context efficiently.

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

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

For a tool with one optional parameter and no output schema, the description is mostly sufficient: it identifies what is listed and where the backups live. It could have briefly described the return shape or ordering, but the current description still gives an agent enough to invoke the tool correctly.

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

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

The input schema already fully documents the only parameter, 'limit', including its default value. With 100% schema description coverage, the description adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

The description uses a specific verb, 'List', and identifies a precise resource: automatic file backups created by Typora in its backups directory. This clearly distinguishes it from siblings such as typora_list_drafts and typora_recent_documents.

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 makes the tool's purpose obvious, so when to use it is implied. However, it does not explicitly contrast it with alternatives or state when not to use it, leaving the usage decision partially to inference.

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

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

With no annotations, the description carries the behavioral burden. It clearly signals a read-only listing operation by using 'List' and 'examining', and identifies the source as the recovery vault. It could be more explicit that listing does not itself recover or delete drafts, but for a simple list tool this is adequate.

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 concise sentences with no filler. The core action and source are front-loaded, and the usage context is added as a useful second sentence.

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

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

For a simple optional-parameter list tool, this description is sufficiently complete: it identifies the data source, purpose, and practical use case. There is no output schema, so the description could specify the exact shape of returned draft objects, but for selection and invocation this is not a critical gap.

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

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

Schema description coverage is 100%, so the parameters limit and query are already fully documented. The description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: list auto-saved/recovered drafts from Typora's recovery vault. It is distinct from likely siblings like typora_read_draft or typora_list_backups by naming the draftsRecover vault, though it does not explicitly contrast sibling tools.

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

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

The description gives clear practical context: use it when recovering unsaved documents or examining emergency drafts. It does not explicitly say when not to use it or name alternatives like typora_list_backups, so it misses the top tier.

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 must disclose behavioral traits. It indicates the tool lists themes and highlights the active and dark theme, which is useful. However, it does not explicitly state that it is a read-only operation or describe any side effects, errors, or edge cases, relying on the implied nature of 'List'.

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 action and resource. It conveys all necessary information without redundancy or filler.

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

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

Given there is no output schema, the description should clarify what the tool returns. It states it lists themes and indicates the active and dark theme, giving a reasonable expectation of output format. It does not mention potential empty results or format specifics, but for a simple list tool this is adequate.

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

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

The tool has zero parameters, so the schema covers everything (100%). The baseline for 0 parameters is 4, and there is nothing for the description to add beyond what is already 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 uses a specific verb ('List') with a clear resource ('all installed user themes and builtin themes') and adds distinguishing details (active theme and dark theme). This clearly separates it from sibling tools like typora_install_theme, typora_set_theme, and typora_get_theme_css, which have different purposes.

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

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

The description implies usage for listing themes but does not explicitly state when to use this tool versus alternatives. There is no mention of alternatives or conditions for selection, leaving the agent to infer from the tool name and description alone.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only states the launch action. It does not mention what happens if the path is invalid, whether Typora is required, or how the tool behaves (e.g., returns immediately vs. blocks). This is a minimal disclosure that leaves significant behavioral ambiguity.

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?

A single sentence with no filler or repetition. The core action and target are stated succinctly, and every word contributes to meaning. No structural issues.

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 launch tool with no annotations and no output schema, the description should clarify expected outcomes (e.g., does it return process info?), error behavior, and any prerequisites (e.g., Typora installed). None of this is addressed, so the description is inadequate for full contextual understanding. The presence of sibling tools like typora_status and typora_close suggests more context is needed to distinguish this from those.

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

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

Schema description coverage is 100%, so the 'path' parameter is already well documented. The description adds a marginal clarification by listing 'text document' and 'workspace folder' as additional accepted types, but this does not meaningfully extend beyond the schema's description. Baseline of 3 applies because the schema carries the informative load.

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

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

The description states a clear verb ('Launch'), resource ('Typora'), and target ('specific Markdown file, text document, or workspace folder'). It distinguishes this from sibling tools like typora_create_document (which creates) and typora_close (which closes), making the intended action 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?

There is no explicit guidance on when to use this tool versus alternatives such as typora_recent_documents or typora_create_document. The description implies opening existing content but does not state exclusions or selection criteria, leaving the agent to infer usage 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 must carry the full burden. It discloses the primary read action and the optional restore (write) behavior, but does not detail side effects (e.g., whether restoring overwrites the target path, whether the draft is deleted after reading, or any permission requirements). It also does not describe the return format. The description is accurate but not deeply transparent about edge cases or consequences of the restore option.

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 leads with the core action ('Read the full text content') and then introduces the optional restore feature. There is no unnecessary verbosity, and every word contributes to understanding the tool's function.

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

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

Given the tool has only two parameters and no output schema, the description is reasonably complete but leaves some gaps. It does not explicitly state what the tool returns (though 'full text content' implies the content itself), and it omits details about error handling, overwrite behavior for restore_to_path, or whether the draft is consumed during reading. For an agent to call this correctly, it would benefit from knowing the exact return structure and any file-write side effects.

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

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

The input schema covers both parameters with clear descriptions (100% coverage), so the baseline is 3. The tool description adds context about the 'draftsRecover vault' for the filename, but this is more about the tool's purpose than the parameter semantics themselves. The restore_to_path parameter is already well-described in the schema, and the description adds minimal extra meaning beyond that.

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 'Read', the target resource 'auto-saved draft from Typora's draftsRecover vault', and the optional restore action. It is specific and distinct from sibling tools like typora_list_drafts (which lists drafts) and typora_open (which opens in the app). It conveys exactly what the tool does in one sentence.

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

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

The description does not explicitly state when to use this tool versus alternatives. It implies you would use this after obtaining a draft filename from typora_list_drafts, but does not name that sibling or provide explicit 'when/when-not' guidance. The schema hints at this via the filename description, but the tool description itself lacks direct usage direction.

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

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

With no annotations, the description carries the full burden. It discloses that the tool reads from history.data and includes 'disk verification' (implying existence checks), but does not explicitly state that it is a read-only operation, what happens if history.data is missing, or how missing files are represented. It adds some context beyond the schema but leaves key behavioral aspects unspecified.

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 primary action and includes relevant details. It is concise with no filler or repetition, earning a high score for efficiency.

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

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

No output schema exists, so the description must convey return structure. It mentions returned fields (timestamp, relative time, disk verification) but does not specify the data structure (e.g., array of objects) or error behavior. For a low-complexity tool with all-optional parameters, this is adequate but not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'disk verification' which loosely ties to the verify_exists parameter but adds no new meaning to limit or query beyond their schema descriptions. It does not clarify formats, defaults, or edge cases, so it adds minimal value over the schema.

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

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

The description clearly states a specific verb (retrieve) and resource (recently opened Markdown documents from Typora's history store), and differentiates from siblings like typora_recent_folders (folders) and typora_list_drafts (drafts). It also adds detail on what is included (timestamp, relative time, disk verification), making the tool's purpose unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of cases where typora_list_drafts or typora_recent_folders would be preferred, and no exclusions or prerequisites are stated. An agent must infer usage purely from the name and description.

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

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

With no annotations, the description carries the full burden. It states a read operation ('Retrieve') but does not disclose details like ordering, whether the current workspace is included, or if the result is limited to only folders. However, the behavior is simple and the description is not misleading, so a mid-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?

The description is a single concise sentence that front-loads the action and resource. There is no wasted wording, and it is easy to parse quickly.

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

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

For a simple retrieval tool with one optional parameter and no output schema, the description is sufficiently complete. It tells the agent what the tool returns (recent folders/workspaces) and does not omit critical details. A minor gap is that it doesn't specify if the history is sorted, but that is not essential for correctness.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'limit' parameter with a default and meaning. The description adds no extra value beyond the schema, so the baseline of 3 is correct.

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 'Retrieve' and the resource 'recently opened workspaces and folders from Typora's history'. It is specific enough to distinguish from sibling typora_recent_documents by mentioning workspaces and folders, which are different from documents.

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 (when you need recent folders/workspaces), but it does not explicitly mention when NOT to use it or point to an alternative like typora_recent_documents. No guidance on selecting between similar sibling tools is provided, leaving it to the agent to infer.

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

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

With no annotations provided, the description carries the full burden and does reveal useful behavior: the output is standalone, portable, and inlines base.css plus theme styling into the #write container. However, it does not disclose edge cases such as what happens when both content and input_path are supplied, whether Typora must be running, or whether the source file is modified, so transparency 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?

The entire description is one dense sentence with no filler. The core transformation is front-loaded, and the parenthetical detail about inlining base.css and theme styling earns its place by clarifying the output format.

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, combined with a fully documented schema, gives an agent enough to understand inputs and the general result for a straightforward render operation. The only real gaps are ambiguous combinations of optional parameters and lack of explicit return/error details, but these are minor given the tool's simplicity and complete schema coverage.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description's phrasing 'Markdown content or an input Markdown file' maps to content and input_path but adds no per-parameter detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description opens with a specific verb ('Render') and names both the input (Markdown content or file) and the output (standalone portable HTML). The mention of Typora's exact CSS themes and inlined base.css clearly distinguishes this from sibling tools like typora_get_theme_css or typora_open, which serve different purposes.

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

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

Usage is implied: use this when Markdown needs to be converted to styled HTML. However, the description does not explicitly state when not to use it or point to alternatives such as typora_create_document or typora_get_theme_css, leaving the agent to infer the right choice from the sibling list alone.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It discloses that the tool mutates Typora's user preferences, but it does not state whether themes must already be installed, whether omitted parameters leave the corresponding mode unchanged, whether changes are reversible, or what happens on invalid input.

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

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

The description is a single front-loaded sentence with no filler. It immediately communicates action, target, and scope, and does not repeat schema content. It is appropriately concise for a simple two-parameter tool.

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

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

For a simple setter, the description plus fully documented schema parameters is close to sufficient. However, the absence of annotations and an output schema leaves open key invocation details such as whether themes must exist beforehand and what a successful call returns. These gaps are meaningful but not disabling.

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

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

Schema description coverage is 100%, so the schema already documents both 'theme' and 'dark_theme' with light/dark-mode semantics and examples. The description's phrase 'standard theme or dark theme' loosely maps to those parameters but adds no new detail about valid names, fallback behavior, or the interaction between the two optional parameters.

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

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

The description opens with a specific action verb ('Set') and names the exact resource and scope: 'active standard theme or dark theme in Typora's user preferences.' This clearly distinguishes it from sibling tools like typora_list_themes, typora_install_theme, and typora_get_theme_css.

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

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

No guidance is given for when to use this tool versus alternatives. It does not mention prerequisites such as using typora_list_themes to find valid installed themes or typora_install_theme before setting a custom theme. The only implied context is the purpose statement, which is not enough.

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 conveys that this is a read-only inspection operation and lists the observable data, but it does not mention behavior when Typora is not running, potential permission issues, or whether the returned state is a snapshot or streaming value.

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 purpose and then packs the key detail list into a parenthetical. Every element earns its place, and there is no redundant or filler content.

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

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

For a zero-parameter status tool with no output schema, the description provides a solid inventory of returned fields and scope (Windows). It could be slightly more complete by stating explicitly that it returns a snapshot and what happens if Typora is not running, but the current level is sufficient for an agent to invoke it appropriately.

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

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

The tool has zero parameters)Skip explanation? No, need justification. The input schema is emptyched, so there are no parameter semantics to clarify. Per the baseline for zero-parameter tools, the description does not need to compensate for missing parameter documentation, and it does not.

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 ('Inspect') and resource ('live running state of Typora on Windows'), then enumerates exactly what is included (process IDs, active documents/folders, memory usage, installation path, app version). This clearly distinguishes it from the sibling action and reading tools, which focus on opening, creating, or retrieving specific resources.

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 its usage: call this when you need to observe the current running state of Typora. However, it does not explicitly state when not to use it or name alternatives, leaving the agent to infer that it is not for opening, creating, or configuring Typora.

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