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 discloses that this creates a thread and requires web mode, and the highlighting analogy clarifies scope, but omits failure behavior (e.g., text not found), required permissions, and that it is a mutation.

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

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

Two sentences, front-loaded with the core action and the environment caveat last. Every element earns its place, though 'opt-in, see README' offloads needed detail to an external document rather than stating it inline.

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 write tool with no annotations and no output schema, the description is thin: it never describes the result of the operation or error conditions. The 100% schema coverage compensates on inputs, but behavioral completeness remains marginal.

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 fully documents all five parameters including the 'occurrence' disambiguation and the 'project' default. The description adds no parameter-level detail beyond the file-passage framing, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Start a new review comment thread on a passage of a .tex file') and adds a vivid analogy ('as if highlighting it in the Overleaf editor'). It distinguishes itself from sibling reply_comment by emphasizing 'new thread,' though it never names the sibling explicitly.

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

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

It provides a real constraint ('Web mode only (opt-in, see README)'), which signals an environment prerequisite, but gives no explicit when-to-use vs reply_comment/resolve_comment guidance. Usage must be inferred from the word 'new'.

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 usefully discloses the output shape (errors and warnings with file and line numbers) and a mode restriction, but says nothing about permissions, whether a PDF artifact is produced, compile time/timeout behavior, or whether a failed compile still returns a result.

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

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

Two tight sentences with the action and output front-loaded and the mode constraint placed after. Every clause earns its place with no filler.

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

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

For a five-parameter tool with a fully documented schema and no output schema, the prose result description (errors/warnings with file and line numbers) plus the mode note is close to sufficient. Minor gaps remain around prerequisites and failure behavior.

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 all five parameters (draft, project, raw_log_lines, include_badboxes, include_warnings) are already fully documented in the schema. The description adds no parameter-level meaning beyond that, 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?

States a specific verb (compile) and resource (the Overleaf project) and describes the result: errors and warnings with file and line numbers. No sibling tool performs compilation, so the purpose is unambiguous, though there is no explicit differentiation text against siblings like download_pdf.

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 adds a genuine precondition ("Web mode only (opt-in, see README)"), which tells the agent when the tool is available. However, it gives no guidance on when to compile versus other actions, no mention of prerequisites like the project needing to be synced, and it defers detail to an external README the agent cannot read.

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

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

With no annotations, the description carries the full burden and does real work: it discloses that deletion is recoverable via Overleaf's History, and that the operation goes through Git with a fallback to an opt-in web mode. It still omits permissions/auth requirements and whether deleting a folder is recursive.

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 short sentences, front-loaded with the action and resource, followed by reversibility and mechanism. No filler or repetition of the tool name.

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

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

For a 3-parameter destructive tool with no annotations and no output schema, the reversibility and mechanism notes are valuable but incomplete: permission requirements, folder-recursion behavior, and failure/confirmation semantics are absent.

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

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

Schema coverage is 67% with commit_message carrying no description anywhere, and the description adds zero parameter-level meaning (path, project, commit_message are all unmentioned). It neither explains the commit message nor clarifies folder-path recursion semantics for 'path'.

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 (delete) and resource (file or folder) with explicit scope (from the Overleaf project). No sibling does deletion, so there is no ambiguity with move_file, write_file, or edit_file.

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 only implied by the noun-phrase purpose; there is no statement of when to delete versus relocate with move_file, or any precondition. The note about restoration and the Git/web-mode mechanism gives adjacent context but not selection guidance.

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

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

With no annotations provided, the description carries the full burden. It does disclose two useful traits: the tool compiles (a non-trivial side effect, not just a read) and it is gated to web mode as an opt-in feature. It omits permission/auth requirements, whether the output path is overwritten, and what happens if compilation fails.

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

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

Two tight sentences with the primary action front-loaded and the environmental caveat second. No filler, no restatement of the title.

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 low-complexity, two-optional-parameter tool with full schema coverage and no output schema, the description covers the essential action and the mode restriction. The remaining gap is the relationship to the `compile` sibling, which leaves the agent's tool-selection decision underspecified.

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% for both parameters, so the schema already documents `project` (ID, URL, or name, with env default) and `output_path` (with cache default). The description adds no format or default information beyond that, so the baseline of 3 applies.

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

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

The description states a concrete two-part action: compile the project and save the PDF to a local path, which is more specific than the title alone. However, it never distinguishes itself from the sibling tool `compile`, so an agent cannot tell whether download_pdf recompiles or reuses existing output, which is exactly the decision it needs to make.

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

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

It gives one real gating condition — 'Web mode only (opt-in, see README)' — which tells the agent this tool may be unavailable in some environments. But there is no guidance on when to prefer this over `compile`, no prerequisites, and the opt-in detail is deferred to an external document rather than stated here.

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 usefully discloses the storage mechanism (Git) and a fallback to an opt-in web mode, plus the unique-match precondition. It omits mutation-relevant context such as permission/auth requirements, what happens if the match fails, and whether the edit is reversible outside Git versioning.

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

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

Three tight sentences with the core action front-loaded, followed by the matching constraint and the storage behavior. No filler; each sentence adds distinct information.

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 mutation tool with no annotations and no output schema, the description covers storage and fallback behavior but leaves gaps around failure modes, permissions, and what a successful/failed edit returns. Adequate but not complete given the complexity.

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

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

Schema coverage is 83%, so the schema already documents most parameters. The description adds genuine meaning beyond the schema by explaining the coupling between old_string and replace_all (exact unique match unless replace_all is set), which clarifies replace_all's purpose better than its bare property description.

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

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

States a specific verb+resource ('Replace an exact string in a project file') and names the persistence target (Overleaf). It implicitly distinguishes itself from the sibling write_file by describing a targeted string replacement rather than a full overwrite, but never names that alternative explicitly.

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

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

The description implies use (targeted edits rather than whole-file writes) and gives the matching precondition (old_string must match exactly once unless replace_all). However, it never states when to prefer this over write_file or write_markdown, so the routing guidance is only implied.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the web-mode-only opt-in constraint and the shape of returned data, but omits pagination, permission/auth requirements, and how it behaves when a project has no comments; it also defers the key constraint to an external README rather than explaining it.

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

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

Two tight sentences, front-loaded with the operation and its return contents. The trailing parenthetical "(opt-in, see README)" is slightly vague but does not bloat the text.

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

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

For a simple two-parameter read tool with full schema coverage and no output schema, the description adequately conveys purpose, contents, and a key environment restriction. It could be more complete with pagination/ordering notes, but nothing essential 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 100% and both parameters (project, include_resolved) are fully documented in the schema, so the baseline is 3. The description adds no extra syntax or default detail beyond what the schema already provides.

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

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

States a specific verb and resource ("List review comment threads") and even enumerates the returned content (commented text, file, line, replies). The read-only framing implicitly separates it from write siblings like add_comment/reply_comment/resolve_comment, but no sibling is named explicitly.

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

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

The only usage guidance is the environment constraint "Web mode only (opt-in, see README)." There is no statement of when to prefer this over other tools or how it relates to resolve_comment/reply_comment, so usage is implied rather than directed.

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

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

With no annotations, the description carries the full burden, and it does disclose a genuine behavioral trait beyond the schema: it recursively follows \input/\include from the main file and reports file and line numbers, which tells the agent the result spans multiple files. Read-only intent is strongly implied by "Show" but not stated, and nothing is said about permissions or limits.

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 dense sentence that front-loads the purpose and appends the two details that actually matter (include traversal, file/line numbers). No filler and nothing redundant.

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 read tool with no output schema and no annotations, the description covers what the tool returns (section hierarchy with file and line numbers) and how it resolves multi-file documents. Minor gaps remain about the exact return shape and whether the operation is guaranteed read-only.

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 both parameters (project, main_file) are already fully documented, including the OVERLEAF_PROJECT_ID default and auto-detection of main_file. The description adds nothing about parameters, so the baseline of 3 applies.

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

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

Names a specific verb and resource ("Show the section structure") and pins down the exact artifact it reflects (\part, \chapter, \section), so the agent knows this is a structural overview rather than a content read. It doesn't explicitly contrast itself with siblings like read_section or read_file, but the distinct output (structure + locations) makes the separation inferable.

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 only implied: the inclusion of file and line numbers suggests it is meant as a navigation/orientation step before reading content, but the description never says when to prefer it over read_file or read_section, nor states any exclusions. Adequate but with a clear gap.

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 behavioral burden, and it delivers almost nothing beyond the name: it does not say whether the listing is recursive, whether folders appear alongside files, what identifier format is returned, or that it is a safe read. Sibling read tools make read-only status likely, but that is inference, not disclosure.

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 short sentence with no filler and the resource front-loaded. It is efficient, though its brevity is partly under-specification rather than deliberate compression.

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-required-parameter read tool with full schema coverage, the definition is barely sufficient. With no output schema, the description should at least hint at what is returned (paths, folder structure), and it does not.

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?

Only one parameter, and the schema documents it fully (100% coverage), including the default to OVERLEAF_PROJECT_ID. The description adds nothing about the parameter, which is the expected baseline when the schema already does the work.

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 (List) and resource (all files) scoped to an Overleaf project, which cleanly separates it from the sibling list_projects. It does not, however, explicitly reference alternatives such as get_outline or read_file, so differentiation is achieved by implication rather than by naming.

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 when-to-use or when-not-to-use guidance and no mention of alternatives. An agent must infer that this is the discovery step before read_file or edit_file.

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 usefully discloses scope (account-level), that IDs are returned, and a mode restriction (web mode only, opt-in), but says nothing about pagination, ordering, or failure behavior when not in web mode.

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 with the core purpose front-loaded and no filler. The trailing '(opt-in, see README)' parenthetical is slightly vague but does not bloat the definition.

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

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

For a simple read-only list tool with one optional parameter this is close to adequate, but with no output schema the description should say more about the returned shape beyond 'with their IDs', and it omits any mention of pagination or result limits.

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% for the single include_archived parameter, so the schema already documents its meaning. The description adds no syntax or semantics beyond what the schema provides, making the baseline 3 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 and resource ('List the Overleaf projects in your account with their IDs'), which is meaningfully distinct from the file-level siblings like list_files and read_file. It does not, however, explicitly name or contrast with any sibling to remove residual ambiguity about project-level vs file-level listing.

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

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

The only guidance is a precondition ('Web mode only (opt-in, see README)'), which is a constraint rather than a when-to-use rule. There is no statement of when to prefer this over list_files or other discovery tools, and the 'see README' deferral leaves the opt-in mechanics unexplained.

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 usefully discloses side effects (missing target folders created) and backend behavior (Git with an opt-in web fallback), which are real behavioral traits. However, it omits overwrite semantics for an existing target, reversibility, and permission/auth needs — critical gaps for a mutation tool.

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

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

Three tight sentences, front-loaded with the core action and example, followed by side-effect and backend notes. Every sentence adds distinct information with no padding.

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?

A mutation tool with no annotations and no output schema, so the description is the sole source of behavioral detail. It covers folder creation, reference updates, and backend mode, but leaves overwrite behavior and failure/auth conditions unaddressed.

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 75%, so the schema already documents most parameters, and the example (intro.tex → sections/introduction.tex) illustrates path/new_path format. But commit_message is undocumented in both places, and no syntax or format detail is added beyond the schema baseline.

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 ('rename and/or move a file or folder within the project') and reinforces it with a concrete path example. An agent can distinguish this from write_file/edit_file without opening a schema.

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

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

Provides an actionable caveat ('update \input/\include references') and notes folder auto-creation, implying usage context, but never says when to use this over siblings like write_file or delete_file, nor any when-not condition. Usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does convey that the target is a text file (implying non-binary content) and that reads can be range-limited, but it says nothing about error behavior for missing paths, permission/auth requirements, or file-size limits.

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 that states the resource first and the optional scoping second. 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?

For a four-parameter read tool with complete schema coverage and no output schema, the definition is nearly sufficient. The only real gap is that it never describes the return shape (file contents as text), which an agent must infer.

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 path, project, start_line and end_line are already fully documented, including the 1-based and inclusive conventions. The description's line-range mention adds no detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Read a text file from an Overleaf project') and adds the optional line-range scope. It is clear what the tool does, but it does not differentiate itself from the close sibling read_section, leaving the agent to infer the boundary.

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 'optionally limited to a line range' implies when the range parameters matter, but there is no explicit when-to-use guidance and no mention of alternatives such as read_section or get_outline for partial/structured reads. Usage is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses matching behavior and that it returns LaTeX source, but omits what happens on an ambiguous title, permission requirements, and project resolution defaults beyond what the schema states.

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, front-loaded with the action and resource, with no filler. The added matching caveat earns its place without bloating the definition.

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 full schema coverage, the description supplies the key return content and matching behavior an agent needs. It could mention ambiguous-title handling, but the essential call information is present.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds matching semantics for the title parameter but says nothing about file or project, making the baseline 3 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 and resource: read the LaTeX source of one section. It distinguishes the tool from read_file by scope ('one section') and from get_outline by returning source content, but does not explicitly name alternatives.

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

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

Gives useful invocation detail (case-insensitive, partial titles work if unambiguous), but does not say when to prefer this over read_file, get_outline, or other sibling tools. Usage is implied by resource specificity rather than explicit guidance.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the web-mode opt-in gate and the prerequisite source of thread IDs, but says nothing about permissions, failure behavior in non-web modes, or whether the reply is reversible/visible to others.

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

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

Two tight sentences with the core action front-loaded and the constraints appended; nothing is redundant or padded.

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

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

The tool is simple (3 params, 2 required), but with no annotations and no output schema the description would benefit from stating what the call returns or confirming the required auth/web-mode setup rather than deferring to the README. It covers the essentials but leaves gaps for a mutation tool.

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

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

Schema description coverage is 100%, so project, content, and thread_id are already documented with format and defaults. The description only restates that thread IDs come from get_comments, adding no syntax or usage detail beyond the schema. Baseline 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 gives a specific verb and resource ("Add a reply to an existing comment thread") and the word "reply" vs. a plain comment reasonably separates it from the sibling add_comment. It also names get_comments as the source of thread IDs, which aids disambiguation, though it never explicitly contrasts itself with add_comment.

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 a clear prerequisite workflow ("thread IDs come from get_comments") and a deployment condition ("Web mode only (opt-in, see README)"). It stops short of naming when-not-to-use or explicitly routing the agent to alternatives like add_comment.

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 must carry the full behavioral burden. It usefully discloses that the action is reversible (resolve or reopen) and requires web mode opt-in, but omits permissions, side effects on notifications, and idempotency details.

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 with no waste. The action is front-loaded, followed by the mode prerequisite, so the agent gets the essential information immediately.

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 state-change tool with a fully described schema and no output schema, the description covers the core action and the web-mode requirement. It could be more explicit about what web mode entails, but it is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including thread_id's format, project defaults, and the reopen flag. The description adds no parameter semantics beyond what the schema provides, making the baseline 3 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 the exact action: mark a comment thread resolved or reopen it. The resource (comment thread) and the state-change operation clearly distinguish it from siblings like add_comment, reply_comment, and get_comments.

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 the context 'Web mode only (opt-in, see README),' which is useful, but does not name alternatives or say when to choose resolve versus reopen beyond the parameter name. Usage is implied by the tool name, with no explicit when-not guidance.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the concrete mutation (adds \usepackage{kotex} to the preamble), a compiler switch to XeLaTeX, the prerequisite (opt-in web mode), idempotency ('if no Korean package is loaded yet'), and the Overleaf fallback. It stops short of describing reversibility or the exact response/return shape.

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

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

Front-loaded with the purpose followed by per-language specifics; every clause earns its place. The second sentence is somewhat dense with nested parentheticals, which slightly hurts scannability but not comprehension.

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 3-param, no-annotation, no-output-schema tool, the description is nearly complete, covering triggers, side effects, prerequisites, and the Overleaf alternative. Minor gaps remain around failure modes and what the tool reports when setup is already satisfied.

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

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

Schema coverage is 100% so the baseline is 3, and the description exceeds it by mapping each enum value ('ko' vs 'en') to a distinct behavioral outcome, which the schema only labels as 'Paper language.' The 'project' and 'main_file' parameters get no additional semantics, but they are already fully documented in the schema.

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

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

States a specific verb and resource ('Prepare the project for writing in Korean or English') and immediately enumerates the concrete effect for each mode. It is distinguishable from all siblings, none of which perform project-level writing setup.

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 an explicit trigger ('Run this before writing Korean text, or when compile reports "Unicode character" errors for Korean') and effectively handles the negative case by telling the agent that 'en' needs no setup. Nothing is left to inference 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 burden and does disclose key traits: overwrite is destructive to existing content, the operation is persisted via Git, and there is an opt-in web-mode fallback. It omits permission/auth requirements and whether a commit is always created, so it is informative but not complete.

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 short sentences, front-loaded with the destructive create/overwrite semantics, then the alternative, then the transport detail. Nothing is padding except a mild redundancy in "and save it to Overleaf".

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 mutation tool with no annotations and no output schema, the description covers the destructive nature, persistence mechanism, fallback path, and the preferred sibling for partial edits. Return value and commit behavior remain unstated, which is a modest gap rather than a blocking one.

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 75% and the description adds nothing about path, content, or project; its only parameter-adjacent contribution is confirming that web mode exists, which clarifies the schema's "project name in web mode" note. commit_message is undocumented in both schema and description, so baseline 3 is appropriate.

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

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

States a specific verb pair and resource ("Create or overwrite a file") plus the target system ("Overleaf project"), so the agent knows exactly what it does. It differentiates itself from edit_file, but does not distinguish itself from the sibling write_markdown, which is also a file-writing tool.

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?

"Prefer edit_file for changing part of an existing file" gives an explicit alternative and the condition that selects it, which is exactly the routing an agent needs. No guidance is offered against write_markdown or when a full overwrite is inappropriate, so it stops short of full when/when-not coverage.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses that writing goes through Git with an opt-in web-mode fallback, that a file target is overwritten by default, and that dry_run only previews without pushing. It does not mention permission/auth requirements or failure modes, but the mutation semantics 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?

Front-loaded with the core action, followed by the supported Markdown syntax, then dry_run and Git behavior. The dense syntax enumeration is long but earns its place by telling the agent which constructs survive conversion; minimal 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 nine-parameter, no-output-schema, unannotated tool, the description is nearly complete: it covers the conversion contract, targeting modes, preview path, and write mechanism. It stops just short of stating return shape or auth prerequisites, but nothing critical to a correct invocation 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 89%, so the schema already documents the nine parameters thoroughly. The description adds some useful glue (dry_run previews LaTeX, section replacement interact with top_level defaults) but mostly restates schema-level behavior rather than adding per-parameter meaning beyond 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+resource: converts Markdown to LaTeX and writes it into the project, with three concrete targeting modes (new/overwritten .tex, replace existing section, append). An agent understands exactly what the tool does. However, it never contrasts itself against close siblings like write_file or edit_file, so sibling differentiation is only implied by the 'Markdown' framing.

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 context is implied (write Markdown when you want LaTeX output) and it usefully recommends dry_run to preview first. But it gives no explicit when-to-use/when-not guidance against alternatives such as write_file, edit_file, or write_markdown vs raw LaTeX paths, leaving the selection decision to inference.

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