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 a read-only 'return' operation but omits the meaning of the recursive parameter, the direction of traversal, and any side effects or error conditions. The phrase 'theorem-like nodes referenced by' does clarify the edge direction, but significant behavioral variability is left to inference.

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 or redundant content. It states the action and resource immediately and uses every word effectively, even though brevity sacrifices behavioral detail addressed in other dimensions.

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?

Although an output schema exists and can explain return values, the description omits the meaning of the recursive flag and does not distinguish this tool from workspace_get_dependencies. These gaps are important for correct invocation, and the schema's zero parameter descriptions do not fill them.

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 0%, so the description must compensate for the bare parameter names. It only clarifies theorem_id as 'the given theorem'; the recursive parameter remains completely unexplained despite having a default value. This is insufficient compensation for the low schema coverage.

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

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

The description uses a specific verb ('Return') and clearly identifies the resource ('theorem-like nodes referenced by the given theorem'). It is unambiguous about the operation, though it does not explicitly differentiate itself from the sibling workspace_get_dependencies 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?

No guidance is provided about when to use this tool versus alternatives such as workspace_get_dependencies or get_dependency_diagnostics. The presence of a workspace-scoped sibling implies a possible selection criterion, but that context is not stated.

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

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

No annotations are provided, so the description carries the full burden. 'Explain' implies a read-only operation, but the description does not disclose any behavioral details such as whether recursive traversal is performed, whether results depend on workspace state, or what the output structure looks like.

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 with no filler or redundancy. It front-loads the core purpose and earns its place, even though other dimensions suffer from missing details.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is too thin. It does not explain what the diagnostics output contains, how recursive affects behavior, or when to choose this tool over related siblings. An agent would likely need to inspect the tool implementation to call it confidently.

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 0%, so the description must compensate. It adds minimal context by saying 'one theorem-like node,' which loosely maps to theorem_id, but it says nothing about the recursive parameter or its meaning. The schema's type and default values are all the agent has to work with.

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 action ('Explain') and the resource ('how dependencies were extracted for one theorem-like node'). This distinguishes it from sibling tools like get_dependencies, which presumably returns the dependencies themselves rather than explaining their extraction.

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 get_dependencies, where_used, or workspace_get_dependency_diagnostics. The description implies a diagnostic context but does not state when it should be preferred.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the high-level return content but says nothing about side effects, error behavior, what 'reproducible launch diagnostics' includes, or whether any checks are performed. The risk is low for a 0-parameter read-only tool, but the disclosure is thin.

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 verb and resource with zero filler. Every word earns its place, and the length is appropriate for a parameterless 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?

Given the absence of an output schema and annotations, the description is the agent's only source of information. It covers the essentials for making the call, but 'reproducible launch diagnostics' is vague and the description does not distinguish this tool from get_dependency_diagnostics or explain what the returned diagnostics enable.

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 and the schema trivially covers 100%, so there is nothing for the description to explain. Per the baseline for 0-parameter tools, a 4 is appropriate since no semantic gap exists.

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 ('Return') with a clear resource ('PaperGraph version and reproducible launch diagnostics'), stating exactly what the tool produces. While it doesn't explicitly name a sibling alternative, no other sibling tool covers environment diagnostics, so it is implicitly distinguishable.

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 guidance on when to invoke this tool, no mention of alternatives such as the closely named get_dependency_diagnostics, and no exclusions. The agent must infer that this is for launch/environment troubleshooting entirely from the name.

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. 'Return' clearly signals a read-only operation and the description discloses what is returned, but it does not address behavior for missing or invalid IDs, access restrictions, or output shape beyond 'full text and metadata'.

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 or redundancy; every word adds meaning.

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 and the description covers the core return value and scope, but with no output schema and no annotations it leaves unresolved how the ID is supplied and what happens on edge cases. It is minimally viable but not 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 0% and the description never mentions theorem_id or how it identifies the node. The parameter name is fairly self-explanatory, but the description does not compensate for the lack of schema-level documentation.

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

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

The description states a specific verb ('Return') and resource ('one theorem-like node'), and clarifies the payload ('full text and metadata'). It is distinct from listing or searching siblings, though it does not name an 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 phrase 'for one theorem-like node' implies this is for fetching a single item by ID rather than listing or searching, but there is no explicit when-to-use guidance or mention of alternatives such as list_theorems or workspace_search_theorems.

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 and the description gives no information about side effects, read-only behavior, permissions, or any impact on the workspace. The user is left to infer that listing is non-destructive.

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 with no redundancy or unnecessary detail. It is well-structured and easy to read.

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

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

The description is too brief to provide complete context. It does not clarify what 'theorem-like environments' includes (e.g., theorems, lemmas, corollaries) or how the 'kind' parameter influences output, leaving significant gaps for the agent.

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

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

The schema has a single optional parameter 'kind' with no description, and the tool description does not mention it at all. There is no explanation of what values it accepts or how it affects the results.

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 action ('List') and a specific resource ('theorem-like environments in the currently loaded paper'). It distinguishes from sibling tools like get_theorem or workspace_search_theorems by focusing on the current paper, though 'theorem-like' is somewhat vague.

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 provided on when to use this tool versus alternatives such as workspace_search_theorems or get_theorem. The description does not mention any conditions or preferred scenarios.

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 state that the tool downloads a source project and builds a theorem graph, but it omits important behavioral details like whether it modifies the workspace, how refresh affects execution, whether network access is required, or what gets persisted. This is a meaningful but incomplete 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?

The description is a single sentence with no filler, and the core action is front-loaded. It is concise and easy to parse, though its brevity contributes to other shortcomings.

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 three parameters, no annotations, and no output schema, this one-sentence description is far from complete. It does not describe return values, optional parameter semantics, preconditions, side effects, or how this tool fits into a larger workflow, making it inadequate for reliable agent 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 0% and the description adds no parameter-level meaning. arxiv_id is implied by the tool name, but refresh and main_file are completely unexplained, so the agent cannot reason about their purpose or valid values.

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

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

The description names a specific verb and resource: 'Download an arXiv source project and build its theorem graph.' This makes the core operation identifiable. However, it does not explicitly distinguish itself from sibling tools like load_arxiv_request or workspace_add_arxiv_paper, so it is clear but not fully differentiated.

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 guidance on when to use this tool versus alternatives such as load_arxiv_request, load_paper, or the workspace_add_* variants. No prerequisites, exclusions, or alternative conditions are mentioned, leaving the agent to infer the appropriate 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, the description carries the behavioral transparency burden. It does disclose a key trait: the load happens only when the request is unambiguous, implying validation failure or ambiguity blocks loading. But it does not describe error behavior, side effects of loading, 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 efficiently conveys the validation-then-load sequence and the ambiguity condition, though 'it' is slightly ambiguous about whether the request or paper is loaded.

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

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

Given the absence of annotations, no output schema, and three parameters, this description is too sparse. It omits parameter semantics, failure behavior, and clear routing relative to the many sibling tools, leaving an agent with insufficient information to invoke it correctly in all cases.

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 0%, so the description must compensate, but it only hints at the 'input' parameter via 'raw arXiv request'. The 'refresh' and 'main_file' parameters are completely unexplained in both the schema and 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?

The description clearly states a specific action sequence: validate a raw arXiv request, then load it only if unambiguous. This distinguishes it from validation-only siblings and from loading already-validated papers, though it does not explicitly name those 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?

The description implies usage: when you have a raw arXiv request that needs validation before loading, and only when the request is unambiguous. However, it gives no explicit when-not-to-use guidance or mention of alternatives like validate_arxiv_request or load_arxiv_paper.

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

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

The description mentions loading and building a theorem graph, which covers the main behavior, but it does not disclose whether the tool has side effects (e.g., saving state) or what it returns. Without annotations, some behavioral aspects remain 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, concise sentence with no redundant or extraneous information. It is well-structured and immediately conveys the tool's purpose.

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?

While the description is sufficient for a simple tool, it omits details about return value (e.g., the built theorem graph), error handling, and specific conditions for use. Given the presence of many related tools, a bit more context on what the output or effect is would improve completeness.

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

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

The schema provides no description for the 'path' parameter, and the description only indirectly implies it is the file path to a local LaTeX paper. It adds some meaning but does not explicitly define path format, required permissions, or relation to the graph building.

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 action (load) and the specific resource (local LaTeX paper) and adds the purpose of building a theorem graph. This makes the tool's primary function unambiguous.

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

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

The description implies usage for local LaTeX files but does not explicitly contrast with sibling tools like load_arxiv_paper. It lacks guidance on when to choose this tool over alternatives, though the name and context provide some implicit 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions persistence and the open/initialize action, but does not explain side effects, whether it creates a new workspace, whether it is idempotent, what it returns, or any required permissions.

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. 'Persistent multi-paper workspace' is a meaningful qualifier, and the sentence is appropriately compact, though 'open or initialize' is slightly 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 tool with no annotations, no output schema, and many workspace-related siblings, the description omits essential context such as expected path format, whether the workspace must already exist, return behavior, and when to call this tool relative to other workspace operations.

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 single required 'path' parameter has no schema description and the description never explains what path means—whether it is an existing directory, a workspace identifier, or a path to be created. The tool name makes the inference plausible, but the description adds no explicit semantic value beyond 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 states a clear action on a resource: 'Open or initialize a persistent multi-paper workspace.' This distinguishes it from sibling tools focused on adding papers or loading individual documents, though the dual phrasing 'open or initialize' leaves some ambiguity about the exact operation.

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 provided on when to use this tool versus any of its many siblings, such as load_paper or workspace_add_paper. An agent has no explicit criteria to determine that this is the required first step before interacting with a workspace.

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 mentions normalization and returning a 'safe next action' but does not explain what 'safe next action' means, whether the tool performs network access, or whether it has side effects. The behavior is only superficially disclosed.

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

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

The description is a single sentence with no filler, front-loading the verb 'Normalize' and the resource. Every word contributes to the stated purpose. It is an example of concise, well-structured writing, even though additional detail is needed elsewhere.

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 no output schema and no annotations, the description is insufficient for an agent to understand the return value 'safe next action' or how to interpret it. It also lacks context for when to call this tool in a workflow, especially with validate_arxiv_request so close in name and purpose. The agent cannot confidently select and invoke the tool correctly based solely on this description.

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 0%, so the description must compensate. It does map 'arXiv ID' to text_id and 'URL' to url, which is helpful, but it does not explain whether the parameters are mutually exclusive, which takes precedence, or what formats are accepted. Both parameters are optional, and the description gives no guidance on how to choose between url and text_id.

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 the specific verb 'Normalize' and names the resource 'arXiv ID and URL inputs', clearly stating the tool's purpose. It also mentions the outcome 'return the safe next action,' which adds specificity. However, it does not differentiate from the similarly named sibling validate_arxiv_request, so it is clear but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It says nothing about preconditions, what input state is expected, or when validate_arxiv_request or load_arxiv_paper would be more appropriate. The presence of validate_arxiv_request as a sibling makes this omission particularly problematic.

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 of behavioral disclosure. It does state the core behavior—validating a raw request and returning a safe next action—but it does not explain what 'safe next action' means, what the possible actions are, or how invalid requests are handled. 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. It front-loads the primary action ('Validate a raw user arXiv request') and then states the output ('return the safe next action'). 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 tool with one input, no output schema, and no annotations, the description is minimally sufficient: it identifies the input and the general nature of the return value. But 'safe next action' remains vague, and the relationship to the similarly named validate_arxiv_input tool is unexplained, leaving the agent without enough information to confidently select or invoke it.

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

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

The schema has only one parameter, 'input', with no description and 0% coverage. The tool description adds that the input is a 'raw user arXiv request', which gives meaningful context beyond the bare parameter name. However, it does not specify the expected format, structure, or example values, so it only partially compensates for the schema's lack of documentation.

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

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

The description clearly states the verb 'Validate' and the resource 'raw user arXiv request', and it indicates the outcome ('return the safe next action'). However, it does not distinguish itself from the sibling tool validate_arxiv_input, which appears to have a very similar purpose.

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 no guidance on when to use this tool versus alternatives such as validate_arxiv_input or load_arxiv_request. The phrase 'safe next action' implies a decision-support role, but no explicit conditions or exclusions are provided.

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, and the description only says that the tool returns referencing nodes. It does not disclose traversal depth, directness of references, or any side effects, though it is implied to be a read-only query.

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 with the verb and object front-loaded. There is no filler or redundant content.

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

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

The description is adequate for a simple tool, especially since an output schema exists. However, it lacks contextual details about reference scope (direct vs. transitive) and how this relates to dependency/citation tools, which would help an agent select 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 single parameter theorem_id is named clearly and referred to as 'the given theorem', but the description adds little beyond the schema. It does not clarify whether the ID is a database key, external identifier, or how it should be formatted.

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?

Clearly states the operation ('return') and target ('theorem-like nodes that reference the given theorem'), which distinguishes it from forward-dependency tools. However, 'theorem-like nodes' is somewhat vague and could be more explicit.

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 provided on when to use this tool versus sibling tools such as get_dependencies or workspace_get_citations. It does not mention alternatives, limitations, or whether references are direct or transitive.

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. 'Add or replace' signals a mutating operation and hints at overwrite behavior, but it does not explain side effects, whether the project is downloaded from arXiv, what happens to existing files, or whether an active workspace is required.

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, tightly worded sentence with no filler or repetition. It is well-formed and front-loaded, though very brief given the tool's parameter and behavioral complexity.

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 annotations, no output schema, and 0% parameter description coverage, this one-line description is not sufficient for an agent to call the tool correctly. It should at least explain what refresh and main_file do and clarify the replacement semantics.

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 0%, and the description mentions none of the three parameters. The tool name implies arxiv_id, but refresh and main_file are completely unexplained, leaving the agent unable to determine their meaning or how they affect the operation.

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 ('Add or replace') and a specific resource ('arXiv LaTeX project') scoped to the active workspace. This clearly distinguishes it from siblings like workspace_add_local_paper and workspace_add_pdf_paper.

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 'in the active workspace' implies the tool operates on the currently open workspace, but the description gives no explicit guidance about when to choose this tool over alternatives such as load_arxiv_paper, workspace_add_pdf_paper, or workspace_add_local_paper. Usage context is implied, not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose the add-or-replace behavior, but it does not explain side effects, whether replacement is keyed by paper_id, or any permission or validation requirements. For a mutating tool, this is a significant 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?

The description is a single front-loaded sentence with no filler; every word contributes to stating the operation and scope. It is appropriately succinct and easy to parse.

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 tool with no annotations and no output schema, critical invocation details are missing. The description does not define path or paper_id precisely, nor does it mention prerequisites or return behavior, so an agent may not be confident about how to call 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 schema provides only names and types with 0% description coverage, so the description needed to explain path and paper_id. It only adds the general 'local LaTeX project' context and does not clarify whether path points to a file or directory, or what paper_id means. This is insufficient to compensate for the schema gap.

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

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

The description states a specific action ('Add or replace'), a concrete resource ('local LaTeX project'), and the scope ('active workspace'). It clearly distinguishes the tool from siblings like workspace_add_arxiv_paper and workspace_add_pdf_paper, so an agent can identify the correct operation.

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 intended scenario: adding a local LaTeX project to the active workspace, and it hints that this is not for arXiv or PDF inputs. However, it does not explicitly name alternatives or state when not to use the tool, leaving the agent to infer routing from sibling names.

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

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

With no annotations provided, the description carries the full disclosure burden. 'Add or replace' usefully reveals mutating overwrite semantics, but it does not state what happens to the replaced paper's associated data (notes, theorem links, reading sessions), what prerequisites exist, or how failures (bad path, invalid PDF) manifest.

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 12-word sentence with the action verb front-loaded and zero filler words. It is well structured and efficient, but it is arguably too short relative to the information load required for a mutation tool with 0% schema coverage.

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 replace-capable operation with two opaque required parameters, no annotations, and no output schema, the description is incomplete. An agent cannot confidently determine what path and paper_id mean, whether the workspace must already be active, or what consequences replacement has on existing associated data.

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 0%, so the description must explain the two required parameters, and it explains neither. 'path' is weakly inferable as a file location, but 'paper_id' is genuinely ambiguous — it is unclear whether it identifies the paper being added, the paper to be replaced, or both — and the relationship between the two parameters is never clarified.

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 ('Add or replace') and resource ('born-digital PDF paper') with a location modifier ('active workspace'). The 'born-digital' qualifier and 'PDF' resource meaningfully differentiate it from workspace_add_arxiv_paper, though the boundary with workspace_add_local_paper is not clearly drawn.

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 when-to-use guidance, exclusions, or alternative-tool routing is present. The phrase 'active workspace' implies a prerequisite (a workspace must be open) but that is never made explicit, and the description gives no hint of when to choose this tool over workspace_add_arxiv_paper or workspace_add_local_paper.

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 disclose behavioral details, but it only says 'Add a note or question.' It does not mention whether the operation mutates state, whether the reading session must already exist, whether the note is immediately persisted, or what the return behavior is. It is not misleading, but it is very thin.

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 with no filler and the action is front-loaded. It could have added useful parameter context without becoming bloated, so it earns a 4 rather than a 5.

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 5 parameters, no annotations, and no output schema, this description is under-specified. The agent cannot determine what target_id/target_kind mean or how note_type should be used, and the required session_id is only implicitly tied to the phrase 'reading session.' The tool needs more context for reliable 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 0%, and the description does not explain session_id, note_type, target_id, or target_kind. 'Note or question' loosely hints at the text content, but it does not clarify how the optional fields control the note's type or target, so it fails to compensate for the low schema coverage.

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

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

The description states a clear action ('Add') and a specific resource ('a note or question to a reading session'), so an agent knows what the tool accomplishes. It does not explicitly contrast this with sibling tools such as workspace_record_reading_checkpoint, so it stops short of full differentiation.

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 no guidance on when to use this tool versus alternatives like workspace_record_reading_checkpoint, workspace_create_reading_session, or workspace_apply_reading_queue_to_session. There are no exclusions, preferences, or conditions provided, leaving the agent to infer usage solely from the tool name.

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 only implies mutation through 'apply' but does not state side effects such as whether checkpoints are created, whether the queue is modified, or whether existing session checkpoints are affected.

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 conveys the essential operation efficiently, though it could add a bit more detail without becoming verbose.

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?

Without annotations or an output schema, this minimal description is insufficient for a mutation-like tool. An agent is left to guess side effects, required preconditions, the role of the optional status parameter, and what the operation returns.

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 0%, and the description adds no meaning to queue_id, session_id, or the status parameter with default 'queued'. The parameter names are somewhat self-explanatory, but 'status' remains unexplained, and the description does not compensate for the schema gap.

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

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

The description states a specific action ('Apply reading queue items') and target context ('as checkpoints in a reading session'), which clarifies the tool's core purpose. It is distinguishable from siblings like workspace_record_reading_checkpoint, though it does not explicitly call out that distinction.

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 usage guidance is provided. The description does not explain when to choose this tool over workspace_record_reading_checkpoint or workspace_create_reading_queue, nor does it mention prerequisites like an existing session or queue.

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 bear the full behavioral transparency burden. It discloses that the queue is 'persistent', but does not explain side effects, whether creating multiple queues for the same result is allowed, whether the operation is idempotent, or what happens to existing queues.

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 with no filler. It front-loads the core purpose, though the brevity crosses into under-specification for the parameters.

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

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

The tool has no output schema and no annotations, so the description is the only source of behavioral and parameter context. It is too sparse to fully support correct invocation, especially for label and recursive, and it does not explain what the tool returns or how it fits into the reading-queue workflow.

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 0%, so the description must compensate. It only hints at the meaning of result_id by saying 'one stored result', but it provides no explanation of label or recursive, both of which have defaults and likely affect queue behavior.

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 action ('Create'), the resource ('persistent reading queue'), and the scope ('for one stored result'). It is specific enough to distinguish from similar concepts like creating a reading session, but it does not explicitly name or 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 provides no guidance on when to use this tool versus alternatives such as workspace_create_reading_session, workspace_list_reading_queues, or workspace_apply_reading_queue_to_session. There is no mention of prerequisites, expected workflow, 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?

With no annotations, the description carries the full burden of behavioral disclosure. It adds one useful trait ('persistent') and notes the active-workspace scope, but it does not explain side effects, whether creating another session is idempotent, how the session relates to a paper, or what the response will contain.

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

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

The description is compact and front-loaded: it opens with the action, then names the object and scope in a single efficient sentence. No words are wasted, though the brevity comes at the cost of the missing semantic detail captured in other dimensions.

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 creation tool with no output schema and no annotations, one sentence is far from complete. It fails to define what a reading session is, how the parameters fit, or what the agent should expect after calling it, making the definition inadequate for reliable selection and invocation.

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

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

Schema description coverage is 0%, so the description needed to explain the roles of paper_id, label, and target_result_id. It does not mention any of these parameters or their relationships, offering no meaning beyond the bare property names 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?

The description clearly states the action ('create'), the resource ('persistent reading session'), and the scope ('active workspace'). It does not explicitly contrast with sibling tools like workspace_create_reading_queue or workspace_record_reading_checkpoint, but 'reading session' is a distinct enough resource to avoid major ambiguity.

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 guidance on when to use this tool versus alternatives such as workspace_create_reading_queue, workspace_add_reading_note, or workspace_record_reading_checkpoint. No preconditions, prerequisites, or exclusions are mentioned, leaving the agent to infer the appropriate 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?

No annotations are provided, so the description carries full behavioral burden. 'Deterministic' is a useful trait (stable output), but it says nothing about whether this is read-only, whether it writes a file, permission requirements, or how the report is delivered.

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 wasted words. Efficient, though almost terse to the point of under-specifying for a two-parameter export 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?

No annotations, no output schema, 0% param coverage, and a non-obvious 'max_candidates' parameter left unexplained. The description does not supply enough context for an agent to invoke this confidently.

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 0% and neither parameter is explained. 'max_candidates' (default 5) is particularly opaque for a report on 'one stored paper' and the description does nothing to clarify it or the paper_id semantics.

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 ('Export') and resource ('deterministic Markdown reading report') scoped to 'one stored paper'. It is distinguishable from export siblings like workspace_export_reading_bundle, but it never explicitly contrasts itself with those siblings.

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

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

The phrase 'for one stored paper' weakly implies the paper must already be in the workspace, but there is no explicit when-to-use, when-not-to-use, or alternative routing among the several other export tools.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It only says 'Export a bundle,' without stating whether the tool is read-only, what format the bundle takes, whether it modifies workspace state, or any output/limits. The phrase is not contradictory but is minimal.

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; the core action is front-loaded. It is concise, though some terms like 'evidence bundle' are undefined, which the conciseness itself does not resolve.

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 output schema and no annotations, the description must explain what the returned bundle is and how it behaves; it does neither. For an export-style tool among many similar reading/export siblings, the current text is too incomplete for reliable selection and invocation.

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

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

Schema description coverage is 0% and the description never mentions paper_id. The term 'paper-level' gives weak contextual confirmation that the ID refers to a paper, but no format, source, or usage example is provided, leaving the agent to infer from the parameter name alone.

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

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

The description names a specific verb, 'Export', a resource ('paper-level evidence bundle'), and the intended audience ('paper-reading consumers'). It is more informative than a tautology, though it does not explicitly differentiate itself from sibling export tools like workspace_export_result_reading_context beyond the 'paper-level' qualifier.

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 guidance on when to choose this tool over the many sibling export/reading tools. The description implies it operates at the paper level, but it never states when this bundle is preferable to workspace_export_result_reading_context or workspace_export_reading_session_summary, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It mentions the output is 'deterministic', which is a useful trait, but does not disclose side effects, format, export destination, or any operational behavior. This is insufficient for a tool with no structured annotation support.

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, tightly-worded sentence that front-loads the core verb and object. Every word adds meaning, and there is no fluff 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 output schema, no annotations, and only a one-sentence description, the tool is under-specified. The exact content of a 'deterministic recovery summary', the output format, whether it creates files or returns text, and error behavior are all unknown, leaving an agent with insufficient context to invoke it reliably.

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 0% and the description does not mention session_id at all. While the parameter name is reasonably self-explanatory, the description provides no elaboration on what constitutes a valid session identifier or how it affects the summary, so it fails to compensate for the missing schema documentation.

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

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

The description clearly states a specific action ('Export') and resource ('a reading session summary'), and adds the meaningful qualifier 'deterministic recovery summary'. It is not tautological and gives a reasonable sense of what the tool produces, though it does not explicitly distinguish itself from sibling export tools like workspace_export_reading_bundle or workspace_export_result_reading_context.

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

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

The description offers no guidance on when to use this tool versus its siblings, no alternative names, and no exclusions. The phrase 'recovery summary' hints at a use case, but an agent has no explicit criteria for choosing this over the other export-related workspace tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether it has side effects, what the exported context contains, or what format is returned. 'Export' alone is ambiguous.

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. Every word contributes to identifying the operation and its target, making it highly concise while remaining readable.

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

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

For a tool with no output schema and no annotations, the description should explain what is returned or exported and when to use this instead of similar export/get tools. It leaves those gaps open, so an agent does not have enough context to invoke it confidently.

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

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

Schema coverage is 0% and the description only indirectly defines result_id as identifying 'one result's proof.' It does not explain what form the ID takes, how to obtain it, or how it relates to result contexts in sibling tools, so the schema gap is only minimally compensated.

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 ('Export') and a clear target: 'focused evidence context for reading one result's proof.' This distinguishes it from session-level exports like workspace_export_reading_bundle or workspace_export_reading_session_summary, though it does not explicitly name those 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?

The phrase 'for reading one result's proof' implies the usage context, but the description gives no explicit when-to-use guidance or exclusions relative to the many sibling tools (e.g., workspace_get_evidence, workspace_export_reading_bundle). An agent must infer which tool to choose.

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 bears the full burden of behavioral disclosure. It communicates that the operation returns data, but it does not explain the meaning of unresolved citations, whether incoming citations require a different lookup path, what happens for missing papers, or how resolved versus unresolved evidence is handled.

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-formed sentence that front-loads the core behavior. There is no filler, repetition of the tool name, or unnecessary detail.

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

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

Although an output schema exists, the description is too thin for a tool with three parameters and zero schema coverage. Key behavioral semantics such as what 'citation evidence' includes, what 'unresolved' means, and how direction affects results are missing, leaving the agent to guess at important invocation details.

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

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

Schema description coverage is 0%, and the description only indirectly clarifies the direction parameter via 'incoming or outgoing'. It provides no additional meaning for paper_id or include_unresolved, and it does not explain allowed direction values or the effect of include_unresolved on the result.

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: it returns citation evidence for a stored paper, and it identifies the key incoming/outgoing axis. It does not explicitly distinguish itself from similar tools like where_used or workspace_get_evidence, but the basic purpose is unambiguous.

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

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

The description gives no guidance on when to use this tool versus siblings such as where_used, get_dependencies, or workspace_get_external_result_mentions. There is no statement of prerequisites, exclusions, or alternative selection criteria, so the agent must infer usage solely from the tool name and sibling list.

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 disclosing behavior. It states that dependencies are returned, implying a read operation, but it does not explain the effect of the 'recursive' flag, whether dependencies are direct or transitive by default, or any restrictions on which theorems qualify. This is a significant 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?

The description is a single concise sentence that is appropriately sized for a simple tool. It is front-loaded with the action and resource, and contains no filler or redundant wording.

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?

Although the tool has only two parameters and an output schema, the description omits important context needed for reliable use: what 'recursive' means, whether the tool is scoped to the current workspace, and how its results differ from related dependency/citation tools. The description alone would not let an agent confidently choose this tool among the many siblings.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints that 'global_theorem_id' is a globally identifying string via 'globally identified,' and it says nothing about the meaning of 'recursive' or the default behavior. Most parameter semantics are left to the agent to infer.

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 action ('Return dependencies') and identifies the target resource as a 'globally identified stored theorem.' This is specific enough to convey the core purpose, but it does not explicitly contrast with siblings like get_dependencies or workspace_get_proof_dependencies, leaving some ambiguity about the exact scope.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention workspace context, when recursive behavior might be needed, or how this differs from similar sibling tools such as workspace_get_proof_dependencies or get_dependencies.

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

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

With no annotations provided, the description carries the behavioral burden. 'Explain how...were extracted' strongly implies a read-only diagnostic operation and clarifies the single-theorem scope. However, it does not disclose whether the call has side effects, how the recursive parameter affects behavior, or what form the explanation takes.

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 or repetition. It is concise and readable, though its brevity leaves important parameter and usage details unaddressed.

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

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

This is a two-parameter tool with no annotations and no output schema, so the description needs to provide substantial context. It omits the meaning/effect of recursive, the expected diagnostic output, and how it relates to the sibling get_dependency_diagnostics, leaving gaps that 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 0%, so the description must compensate for missing parameter documentation. It only alludes to the required parameter via 'for one theorem' and says nothing about the optional recursive parameter, leaving half of the parameter surface unexplained.

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 ('Explain') and identifies the resource ('how workspace dependencies were extracted for one theorem'), making it clear this is a diagnostic tool rather than a dependency-computation tool. It does not explicitly distinguish itself from the similarly named sibling get_dependency_diagnostics, so it stops short of full differentiation.

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 no explicit guidance on when to use this tool instead of alternatives such as get_dependency_diagnostics or workspace_get_dependencies. 'For one theorem' is a scoping hint, but no when-to-use or when-not-to-use context is provided.

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 present, so the description carries the full behavioral burden. It only says 'Return', which implies a non-mutating read, but it does not disclose error behavior, whether node and edge IDs share a namespace, or any prerequisites. For a tool with zero annotation coverage, this is thin.

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; the verb and object come first. It is appropriately short for the simple interface.

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 annotations and no output schema, the description leaves the agent without enough context about valid IDs, return shape, and failure modes. The one-sentence description is too sparse to confidently invoke this tool among more than 40 siblings.

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

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

The schema has 0% description coverage, and the sole parameter node_or_edge_id is undocumented. The description mentions 'one evidence node or edge' but gives no ID format, examples, or guidance on how to distinguish node IDs from edge IDs.

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

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

The description names a specific verb ('Return'), a specific target ('one evidence node or edge'), and the content type ('metadata and source spans'). It is clearly distinct from sibling getters like workspace_get_paper and workspace_get_result, though 'evidence node' is somewhat domain-specific.

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 choose this tool over siblings such as workspace_get_source_slice, workspace_get_citations, or workspace_get_dependencies. The phrasing only implies use when evidence metadata/source spans are needed, with no explicit alternatives 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, and the description only says 'Return...'. It does not explicitly state that the operation is read-only, what happens if result_id does not exist, or whether results are paginated or ordered. The 'get' naming implies safety, but the description itself does not carry the behavioral transparency burden.

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. Every word contributes to identifying the operation and its source, making it appropriately concise for such a simple one-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?

The tool has low parameter complexity and an output schema, so the brief description is not catastrophic. However, it omits useful context about what 'external result mentions' are and how this tool relates to external-import planning or other result getters, leaving an agent to infer that from the sibling list.

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

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

The schema only labels result_id as 'Result Id' with no description. The description adds meaning by indicating that the ID belongs to a result whose proof evidence is searched. It does not specify ID format, how to obtain it, or what counts as an 'external result mention,' so it only partially compensates for the 0% schema coverage.

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

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

The description uses a specific verb ('Return') and resource ('external result mentions') and identifies the source ('from a result's proof evidence'), so an agent can tell what the tool returns. It does not explicitly contrast with sibling tools such as workspace_get_citations or workspace_get_evidence, so it stops just short of full differentiation.

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 guidance on when to prefer this tool over closely related siblings like workspace_get_evidence, workspace_get_citations, or workspace_plan_external_imports_for_result. The phrase 'from a result's proof evidence' provides a data source, but not selection context 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 behavioral disclosure burden. It states a read-only return behavior, which is useful, but it does not disclose error/not-found behavior, prerequisites such as an open workspace, or what 'counts' specifically refers to.

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 short, front-loaded sentence with no filler. Every word contributes to describing the tool's core functionality.

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 getter, the description covers the basics, but with no annotations and no output schema, the vague phrase 'metadata and counts' leaves return structure and the meaning of 'counts' to inference.

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

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

The schema has only one parameter, paper_id, with 0% description coverage. The description does not explain the format or source of paper_id, but the name plus 'one stored paper' makes the parameter's referent reasonably clear, adding limited semantic context.

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 ('Return') and a specific resource ('one stored paper'), and indicates the result content ('metadata and counts'). It clearly differentiates this from list-type siblings, though it does not explicitly name an alternative.

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 'for one stored paper' implies this tool is for retrieving a single paper's metadata and counts, but the description gives no explicit when-to-use vs. when-not-to-use guidance and does not mention alternatives like workspace_list_papers.

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 fully disclose behavior. It indicates a read-like operation ('Return') but does not state whether it is read-only, what happens on missing paper_id, whether max_candidates affects results or errors, or any side effects. The 'evidence-first first-load map' is left undefined, so the agent cannot anticipate the output shape or failure modes.

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, tightly worded sentence with no filler or repetition. It front-loads the core purpose and avoids redundancy. However, its brevity borders on under-specification, which is why it earns a 4 rather than 5 – it is concise but sacrifices essential detail.

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

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

The tool has two parameters, no output schema, and no annotations, so the description is the sole source of context. It fails to explain what a 'map' is, what 'evidence-first' means, how max_candidates behaves, or what the return value looks like. For a tool with this complexity, the description is clearly insufficient for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must explain both parameters. It mentions neither paper_id nor max_candidates. paper_id is self-explanatory, but max_candidates is cryptic; the agent has no idea what it limits (candidates for what?) or how it influences the result. The description adds zero value over the raw 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 it returns a specific artifact ('evidence-first first-load map') for a single stored paper, using a distinct verb ('Return'). It distinguishes itself from sibling tools like workspace_get_paper (which likely returns the paper object) and workspace_get_evidence (which returns evidence). However, the term 'evidence-first first-load map' is jargon and not explained, which slightly reduces clarity.

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 provided on when to use this tool versus alternatives. There is no mention of when it is appropriate, what scenarios it fits, or when to choose a sibling tool instead. The description is purely declarative with no 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?

No annotations are present, so the description carries the full burden. It signals a read operation via 'Return' but does not disclose behavior such as whether dependencies are direct or recursive, performance implications, or output format.

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 efficient sentence with no filler, and the core action is front-loaded. It sacrifices helpful detail but is not 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?

For a tool with no output schema and a very close sibling (workspace_get_dependencies), the description is too thin: it omits recursive behavior, result_id provenance, output shape, and when to use alternatives.

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 0%, and the description only implies that result_id identifies a stored evidence result. It does not explain the meaning or effect of the recursive parameter (default false), nor what an evidence result ID looks like.

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 action ('Return') and resource ('proof dependency evidence for one stored evidence result'), which distinguishes it from generic dependency tools in the sibling list. However, it does not explain what 'proof dependency evidence' means or how this differs from workspace_get_dependencies.

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 on when to choose this tool over siblings such as workspace_get_dependencies or get_dependencies. The description only states what it returns, leaving selection 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 provided, the description carries the full burden of behavioral disclosure. It does add useful traits: the queue is persistent and the items are ordered. However, it does not disclose behavior for invalid or missing queue_id, whether the operation is read-only, or what the returned object structure looks like beyond 'ordered items'.

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. 'Persistent' and 'ordered items' are meaningful qualifiers that add value without bloating 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?

The description conveys the core returned item concept: one persistent reading queue with ordered items. However, given no output schema and no annotations, it leaves gaps around error behavior, queue existence, and how this getter fits with related queue operations.

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 description does not explain queue_id at all, and schema description coverage is 0%. The single parameter is inferable from its name and the tool's 'get' semantics, so this is not severely misleading, but the description fails to compensate for the missing schema descriptions.

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

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

The description uses a specific verb ('Return') and names the exact resource ('one persistent reading queue') while adding that it contains ordered items. This clearly distinguishes it from sibling tools like workspace_list_reading_queues, which lists many queues, and workspace_create_reading_queue, which creates a queue.

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 no guidance on when to use this tool versus alternatives such as workspace_list_reading_queues or workspace_apply_reading_queue_to_session. There are no explicit conditions, prerequisites, or exclusions; the usage context is only implicitly suggested by the tool name and queue_id parameter.

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 behavioral weight. 'Return' and 'persistent' suggest a read-only retrieval of stored data, but the description does not disclose error behavior, permissions, or what happens when the session_id does not exist. For a simple getter this is acceptable 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?

A single, front-loaded sentence with no filler. Every word adds meaning: 'persistent' signals state, 'checkpoints and notes' signals returned content, and 'one' signals a singular lookup.

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 a simple single-parameter getter, and the description names the resource and returned content. However, with no output schema and no parameter semantics, an agent still lacks guidance on session_id sourcing and not-found behavior, leaving the description minimally viable rather than 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 0%, and the only parameter, session_id, is documented only by its title. The description does not explain what session_id values look like, where to obtain them, or how they relate to the reading session being returned, so it fails to compensate for the sparse schema.

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

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

The description uses a specific verb ('Return') and resource ('persistent reading session') and notes that it includes checkpoints and notes. This clearly distinguishes it from create/list/queue tools, though it does not explicitly name a sibling alternative.

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 when a caller needs a single existing reading session with its checkpoints and notes, but it does not explicitly state when not to use it or name alternatives such as workspace_list_reading_sessions or workspace_get_reading_queue. The usage context is inferred rather than stated.

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

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

With no annotations, the description carries the full burden. 'Return ... with source spans' conveys an idempotent read and the included content, which is adequate for a simple getter, but it does not disclose not-found behavior, error cases, or whether source spans are always present.

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 the key output detail. Every word contributes.

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 getter, this is close to sufficient, but without an output schema or usage guidance the agent is left without a clear return shape beyond 'source spans' or context about when this tool is preferable to its siblings.

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

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

Schema description coverage is 0% and the description only loosely implies that result_id selects the stored evidence result. It does not explain the ID format, how to obtain it, or what 'source spans' contains, so the agent must infer parameter semantics from the tool name.

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 ('return') and resource ('one stored evidence result') and adds the output characteristic 'with source spans'. This distinguishes it from list_results and result_proof tools, though it does not explicitly name a sibling.

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 workspace_get_evidence, workspace_get_result_proof, or workspace_list_results. The use case is implied by the name but never stated, and no exclusions or alternatives are mentioned.

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 behavioral burden. 'Return' indicates a retrieval operation with no mutation, and 'one stored evidence result' signals a single-record lookup, but the description does not disclose edge cases (e.g., missing result_id, not-found behavior) or the nature of the returned evidence.

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 one sentence with no filler; the key action and target are front-loaded. It is concise without being a tautology, though the brevity comes at the cost of parameter and context detail.

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

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

With no annotations, no output schema, and zero parameter coverage, the description leaves ambiguity about what 'proof evidence' consists of, what result_id references, and how this differs from sibling evidence/result getters. It is functional but under-specified for an agent that must select among many workspace_get_* tools.

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

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

Schema coverage is 0% and the description does not explicitly define result_id. It only implies that result_id identifies the stored evidence result, leaving the agent to infer the type, format, and source of the ID.

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 ('Return') and resource ('proof evidence') and scopes it to 'one stored evidence result,' which conveys the core function. It does not explicitly contrast with sibling tools like workspace_get_evidence or workspace_get_result, but the resource phrase is specific enough to avoid tautology.

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 guidance on when to choose this tool over workspace_get_evidence, workspace_get_proof_dependencies, or workspace_get_result. The single sentence implies use when proof evidence for a result is needed, but it provides no 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?

With no annotations, the description carries the disclosure burden. It adds a genuinely useful behavioral trait by promising deterministic, local, read-oriented paths, suggesting a safe idempotent operation. However, it remains silent on path existence, error behavior for invalid result IDs, and the impact of the recursive flag, so transparency is only 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 description is a single, front-loaded sentence with no filler or repetition, making it easy to scan. It is appropriately terse, though it could have used one more clause to convey the recursive parameter without becoming verbose.

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 or annotations exist, and the description does not explain the return format, what a 'reading path' consists of, or how recursive changes the result. Given a required result_id and an optional recursive flag, an agent lacks enough context to know the exact effect of recursion or what to do with the returned paths. The tool is too opaque relative to its sibling-rich environment.

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 0%, so the description must compensate, but it only maps 'one result' to result_id. The recursive parameter—a boolean with default true—receives no explanation, leaving a core behavioral switch undocumented. This is partial compensation at best.

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 ('Return') with a concrete resource ('deterministic local reading paths') and scopes it to 'one result,' which differentiates it from sibling getters like workspace_get_result and workspace_get_reading_session. The modifiers 'deterministic' and 'local' add precision about what kind of path is returned.

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

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

The description states only what the tool returns; it gives no guidance about when to choose this tool over sibling tools such as workspace_get_result, workspace_get_result_proof, or workspace_export_reading_bundle. There are no prerequisites, exclusions, or alternative-selection conditions, so an agent must infer usage entirely from the tool name.

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 behavioral disclosure burden. It indicates a read-only operation returning source text, which is helpful, but it does not explain what happens when multiple IDs are supplied, how 'context' affects the result, or whether errors occur for invalid IDs. Adequate for a simple read tool 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 efficient sentence with the action and target front-loaded. There is no filler or redundancy, though the brevity sacrifices useful operational detail.

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

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

With no annotations, no output schema, and four parameters lacking schema descriptions, the single sentence is not enough to invoke the tool confidently. The behavior of context, ID selection semantics, and expected result format are all missing, so an agent would likely need to guess.

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 0%, so the description must compensate. It adds meaning by tying span_id, result_id, and proof_id to their conceptual resources, but it fails to explain the 'context' parameter, the relationship among the three ID parameters, or the expectation that exactly one should be selected. A significant parameter is left undocumented.

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 ('Return') and resource ('bounded source text around one span, result, or proof'), making the core purpose clear. It is slightly ambiguous what 'bounded' means and it does not differentiate from sibling getter tools, but the intent is understandable.

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

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

The description provides no guidance about when to use this tool versus alternatives like workspace_get_result, workspace_get_proof_dependencies, or workspace_get_evidence. No exclusions, prerequisites, or alternative routing are mentioned, leaving usage entirely 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, and the description only implies a read-only action via the verb 'list'. It does not disclose any potential side effects, default behaviors, or limitations beyond the basic listing operation.

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, clear sentence with no unnecessary words. It is concise and well-structured, making it easy to understand at a glance.

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

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

The description is minimal but adequate for a simple list operation. However, it does not specify what information is returned (e.g., paper IDs, titles, metadata) or any inherent ordering or filtering, which could be useful for an agent to predict the tool's 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?

With zero parameters, the baseline score is 4. The description does not need to add parameter-specific meaning, and it correctly reflects that no arguments are required.

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 action (list) and the resource (papers) within the context of the active workspace. It is specific enough to distinguish from sibling tools that list other resources like theorems or results.

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

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

The description provides no guidance on when to use this tool versus alternative list tools among the siblings. There is no mention of filters, sorting, or scenarios where other tools would be more appropriate.

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 communicates that queues are persistent and scoped to the active workspace, and 'List' implies a read-only operation. It does not disclose filtering behavior, ordering, pagination, or side effects, though for a simple listing tool the lack of explicit side-effect disclosure is less critical.

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?

Single sentence, front-loaded with the action, resource, and scope; no filler. It is efficient and easy to parse, though it omits some useful supporting detail.

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

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

For a two-parameter list tool with no annotations, the description is underspecified: it ignores status and paper_id and gives no hint about how to filter or whether results are mutable. The output schema supplies return shape, which helps, but does not compensate for the missing parameter and behavioral context. Overall it is a viable one-line definition for the simplest 'list everything' call, but not complete for the full parameter set.

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

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

The schema has two optional parameters, status and paper_id, with zero description coverage, and the tool description does not mention either. The agent has no guidance on what values are valid or how filtering works. Thus the description adds no meaning beyond the parameter names.

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

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

The description names a specific operation ('List'), a specific resource ('persistent reading queues'), and a scope ('active workspace'). It clearly reads as a list action and, by naming 'persistent', hints at the distinction from reading sessions. It does not explicitly contrast with workspace_create_reading_queue or workspace_get_reading_queue, so it stops short of fully differentiating among siblings.

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

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

The phrase 'in the active workspace' gives useful context for when the tool applies, and the verb 'List' implies it is the collection-view counterpart to workspace_get_reading_queue. However, it provides no explicit when-to-use/when-not-to-use guidance and does not mention alternatives or exclusions. Usage must be inferred from the name and the sentence.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'List' clearly signals a read-only operation, and 'persistent' plus 'active workspace' adds scoping context. There are no misleading or hidden behavioral claims.

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 and contains no redundant or filler content. Every word contributes meaning.

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 and has an output schema, so return values are likely documented elsewhere. However, the optional parameters are completely unexplained in both schema and description, leaving a meaningful gap for agents that need filtered results.

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 0%, and the description does not mention the optional filters 'status' or 'paper_id' at all. An agent cannot determine valid values or filtering semantics from either the schema or the 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?

The description clearly states the operation ('List'), the resource ('persistent reading sessions'), and the scope ('in the active workspace'). This distinguishes it from singular getter tools like workspace_get_reading_session and from queue-listing siblings.

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

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

No guidance is provided about when to use this tool versus alternatives such as workspace_get_reading_session or workspace_list_reading_queues. The description only states what the tool does, not the conditions that should trigger its use.

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

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

No annotations are provided, so the description carries the full disclosure burden. It conveys that this is a read-only listing scoped to the active workspace, but it does not mention whether an active workspace must already be open, how results are ordered or paginated, or any side effects. This is minimal disclosure for a list operation but lacks meaningful behavioral context.

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

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

The description is a single efficient sentence with no filler; it front-loads the verb and resource and adds the workspace scope. It is appropriately tight, although that tightness comes at the cost of missing contextual detail.

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

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

For a tool with three optional but effectively undefined parameters and no annotations, this description is too thin. It does not explain any of the filters, the relationship between 'results' and 'evidence', or when an agent should prefer this over related sibling tools. The output schema mitigates return-value questions but not invocation decisions.

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 0% and the description does not mention kind, limit, or paper_id. An agent cannot infer what values kind accepts, what paper_id filters by, or how limit behaves from the description alone. The schema provides only names, types, and defaults, so the description adds no parameter-level meaning.

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'), a distinctive resource ('stored evidence results'), and a scope ('across the active workspace'). This distinguishes it from sibling list tools like workspace_list_papers and from single-result accessors like workspace_get_result, though it does not explicitly name any alternative.

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 guidance on when to choose this tool over workspace_get_result, workspace_get_evidence, or the other list-related tools. No mention is made of intended workflows, prerequisites, or exclusions. The only implied usage is 'list results,' which is not enough for an agent to select it confidently among many siblings.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It does not disclose whether this tool mutates the workspace, creates a queue, performs network fetches, or simply returns a read-only plan. The word 'Plan' hints at a non-executing action, but this is not explicit enough for an agent to safely predict side effects.

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 short sentence with no filler words. It front-loads the main action and object. The main issue is not length but ambiguity in the verb 'Plan'.

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 no annotations, no output schema, and related sibling tools, the description is under-specified. An agent cannot determine the return value, whether executing the plan changes state, or how this paper-specific tool relates to the result- and queue-specific variants. More operational context is required.

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

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

The schema has one parameter, paper_id, with 0% description coverage. The phrase 'one stored paper' at least implies that paper_id must refer to an existing paper in the workspace, which adds some meaning beyond the schema. However, it does not explain where to find valid paper IDs, what format they take, or how this paper_id relates to the imported arXiv papers.

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

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

The description names a verb and a resource: 'Plan external arXiv imports visible in one stored paper.' It conveys some scope, and the paper focus helps distinguish it from the result/queue sibling tools. However, 'plan' is ambiguous: it does not explain whether this returns a plan, schedules imports, or lists importable papers, so the purpose remains vague.

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 guidance about when to use this tool versus the closely related workspace_plan_external_imports_for_result and workspace_plan_external_imports_for_queue. The only signal is the word 'paper' in the name and 'one stored paper' in the description. No exclusions, prerequisites, or alternative-selection criteria are given.

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 behavioral disclosure burden. 'Plan' is ambiguous: it could mean return a computed plan, persist something, or fetch external metadata. The description does not mention side effects, return values, or whether the operation is read-only.

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 with no filler or repetition. It is front-loaded with the core action and resource, though it is so brief that it misses important behavioral context.

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 output schema and no annotations, the description is not complete enough for an agent to invoke the tool confidently. It does not explain what a 'plan' consists of, whether imports are modified, or what the agent should expect in response.

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

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

The schema has one parameter, queue_id, with 0% description coverage. The description adds only that the tool concerns 'one reading queue,' which mostly restates the parameter name. It does not explain queue_id format, where to find it, or any constraints.

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 has a specific verb ('Plan') and resource ('external arXiv imports referenced by one reading queue'), so an agent can tell this is about planning imports for a queue rather than executing them. It does not explicitly differentiate itself from the sibling tools for_result and for_paper, but the queue scope is clear.

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 no guidance on when to use this tool versus sibling tools such as workspace_plan_external_imports_for_result or workspace_plan_external_imports_for_paper. It also does not state prerequisites like whether the reading queue must already exist.

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 must disclose side effects and behavior on its own. 'Plan external arXiv imports' suggests planning rather than executing, but it does not state whether the tool mutates state, accesses external services, requires permissions, or returns a plan. This leaves the agent guessing about observable effects.

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 loses a point only because the term 'plan' is left vague; otherwise it is appropriately compact.

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 annotations, no output schema, and only one sentence of description, an agent lacks information about what the plan contains, how recursive changes behavior, and what side effects or prerequisites apply. This is insufficient for a non-trivial planning tool with two parameters and many planning siblings.

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

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

Schema description coverage is 0%, so the description must compensate for the input schema's bare property names. It only implicitly explains result_id via 'one result' and says nothing about the recursive boolean, its default true behavior, or its effect on planning.

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

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

The description names a specific action (plan), resource (external arXiv imports), and scope (one result's reading path), so an agent can tell it apart from actual import tools like workspace_add_arxiv_paper. It does not explicitly distinguish from the queue/paper planning siblings, though the phrase 'for one result's' narrows the target.

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 'for one result's reading path' implies the tool is appropriate when planning imports for a single result, but the description gives no explicit when-to-use or when-not-to-use guidance, and no alternatives such as workspace_plan_external_imports_for_queue or workspace_plan_external_imports_for_paper are mentioned.

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 carry the full burden of behavioral disclosure, but it only says 'Create or update.' It does not describe what a 'checkpoint' is, whether the operation is idempotent, what effects occur on the target, whether existing values are overwritten, or what happens on invalid inputs. This is minimal for a mutating 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?

The description is a single sentence with no wasted words and is front-loaded with the core action. It is appropriately concise, though it achieves that at the expense of needed detail.

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

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

For a tool with 6 parameters, required fields, no output schema, and no annotation support, this description is severely incomplete. It omits expected fields semantics, return behavior, and any differentiation from a large set of workspace reading siblings, leaving agents unable to confidently invoke it correctly.

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

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

Schema description coverage is 0%, and the description provides no additional meaning for the six parameters. It does not explain status values, target_kind options, how target_id maps to a resource, what evidence should contain, or how session_id relates to a reading session. The description entirely fails to compensate for the schema being undocumented.

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-resource pair: 'Create or update a reading checkpoint' in the active workspace. It clearly identifies the operation and resource, though it does not differentiate it from sibling reading tools such as workspace_add_reading_note or workspace_create_reading_session.

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 provided on when to use this tool versus alternatives, nor any conditions for create versus update. The phrase 'active workspace' hints at a prerequisite, but it is not explained, and no exclusions or routing cues are given.

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 states the scope ('active workspace') but does not clarify search semantics such as exact vs. fuzzy matching, case sensitivity, whether filtering by kind or paper_id narrows scope, or whether the operation is read-only. The description is too thin for a search tool with no annotation support.

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. Every word contributes to the core purpose, making it easy for an agent 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?

With four parameters, no annotations, and several closely related sibling tools, the description is under-specified. It does not explain how filters interact, what counts as a match, or when this tool should be chosen over list_theorems or get_theorem. The presence of an output schema reduces the need to describe return values, but significant operational context is still 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 0%, so the description must compensate, but it only explains the general search target ('theorem titles and bodies'). It does not clarify the meaning of 'kind', 'paper_id', or 'limit'. The query parameter's role is inferable from the description, but the filter and pagination parameters are left entirely to the schema.

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

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

The description specifies a clear verb ('Search'), a resource ('theorem titles and bodies'), and a scope ('across the active workspace'). This distinguishes it from sibling tools like list_theorems and get_theorem, which imply enumeration and single-item retrieval respectively.

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 this tool is for query-based search across the active workspace, but it does not explicitly state when to prefer it over list_theorems, get_theorem, or where_used. No alternative tools or exclusions are mentioned, leaving usage conditions somewhat inferred.

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