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

Discloses that it removes all color overrides and returns elements to default appearance. Returns count of processed elements. Without annotations, this provides adequate transparency for the tool's effect, though it omits details like undo capability or permission requirements.

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?

Starts with a focused one-line purpose, followed by a brief elaboration and well-structured Args/Returns sections. Every sentence adds value without redundancy.

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

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

Covers the main action, parameter, and return value adequately for a simple tool. Lacks mention of error handling (e.g., invalid category) or prerequisites, but overall is sufficient given the tool's simplicity.

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's Args section provides a clear explanation of category_name with examples ('Walls', 'Doors'), adding significant meaning beyond the schema which only has a title and type. With 0% schema coverage, this fully compensates.

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 first sentence clearly states the action: 'Clear color overrides for elements in a category.' It specifies the resource (color overrides for category elements) and the verb (clear). This sufficiently distinguishes it from siblings like color_splash or modify_element.

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 use this tool versus alternatives (e.g., individually clearing overrides on elements). No context on prerequisites or conditions like needing a valid category that has overrides.

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 of disclosing behavior. It explains the save parameter's effect, but it does not warn about data loss when save=False or describe behavior when no document is active. This is a notable omission for a destructive 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 extremely concise, consisting of a single purpose line and a compact Args block. Every sentence adds value with no fluff.

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

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

For a simple one-parameter tool, the description covers the core functionality and parameter semantics. However, it lacks important safety context (e.g., unsaved changes are lost when save=False) and does not address edge cases like no active document. Given no annotations, these gaps make it incomplete.

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 clearly explains the 'save' parameter ('If True, save before closing; If False, close without saving'), adding meaning beyond the schema's type and default. However, it does not elaborate on what 'save' means in the Revit context (e.g., local save vs. central file).

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 'Close the active Revit document' with a specific verb and resource. It is distinct from sibling tools like open_document and save_document.

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

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

The description provides clear context for when to use the tool (closing the active document), but it does not explicitly mention alternatives or exclusions. Its primary purpose is self-evident.

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

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

The description explains that elements with the same parameter value get the same color, and mentions optional gradient and custom colors. It also describes return value with statistics, but lacks details on persistence or reversibility. Since no annotations exist, the description covers behavior adequately.

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 structured with a brief summary followed by parameter descriptions. It is concise and front-loaded, though the parameter list could be more compact. Overall, it is clear and without redundancy.

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

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

The description covers the tool's core functionality and all parameters, and mentions return values. Given no output schema, the description is fairly complete, though it could mention error handling or edge 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?

The description provides detailed parameter explanations beyond the schema, including example values and formats (e.g., hex for custom_colors). With 0% schema coverage, the description compensates well by clarifying each parameter's role.

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

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

The description clearly states the tool's purpose: coloring Revit elements based on parameter values, with examples of parameters. It distinguishes from siblings like 'clear_colors' or 'set_parameter'.

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, nor any exclusions or prerequisites. It only describes the function without contextual usage advice.

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?

Discloses key behaviors: no auto-transaction, print output returned, variables available, and UI operations outside transactions. No annotations provided, so description carries full 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?

Well-structured with sections, front-loaded purpose, and helpful examples, though slightly lengthy.

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

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

Covers tool purpose, variables, transaction handling, and usage tips sufficient for correct invocation, despite no output schema or annotations.

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 has 0% description coverage; description explains code parameter with context of available variables and print, and description parameter as label, adding significant 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 clearly states it executes IronPython code in Revit context, listing specific variables and capabilities, distinguishing it from siblings that handle specific operations.

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?

Implicit guidance is given through transaction and UI operation examples, but no explicit when-to-use or alternatives compared to 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 present, so the description carries full burden. It discloses return fields, that category_counts is always computed, truncation flag, and instructions to compare total_elements vs returned_elements and increase limit, providing strong behavioral insight beyond the tool's name.

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 with the main purpose, followed by return details, truncation handling, and parameter explanations. Every sentence contributes information, with no redundant filler.

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

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

Given the tool has no output schema, the description sufficiently covers return values, truncation handling, and optional parameter effects. It covers the tool's core behavior and edge cases (truncation) completely 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?

The schema only provides titles and defaults, so the description fully compensates by explaining limit as maximum number to return and include_levels/include_location semantics with exact output implications. This adds meaning the schema lacks.

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 precise verb 'Get' and specifies the resource 'elements visible in the currently active view in Revit', clearly distinguishing it from sibling tools like get_selected_elements or list_revit_views. The scope 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 clearly states it retrieves elements in the active view, implying when to use it, but it does not explicitly contrast with alternative tools such as get_selected_elements or get_revit_view, nor does it provide exclusion criteria. This is acceptable context but lacks explicit alternative naming.

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 openly lists the specific return fields (view name, type, ID, scale, detail level, crop box status, etc.), which tells the agent what to expect from the tool. It does not mention read-only status explicitly, but 'Get' implies a read operation with no side effects. This is better than many tools that fail to describe outputs.

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 extremely concise: one sentence stating the purpose, followed by a bullet list of the comprehensive information returned. Every sentence earns its place, and the structure is front-loaded with the primary purpose. No filler or redundancy.

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

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

For a zero-parameter, read-only tool with no output schema, the description is quite complete—it lists all the key data fields the tool returns. It lacks explicit guidance about when to use this versus get_revit_view, but the purpose is clear enough that this is a minor gap. Overall, it adequately covers the relevant context for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, and the schema is an empty object. Per the rubric, a baseline of 4 is appropriate for 0 parameters since there is nothing for the description to add. The description does not need to explain parameters that do not exist.

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

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

The description clearly states the tool's purpose: 'Get detailed information about the currently active view in Revit.' This uses a specific verb ('Get') and resource ('currently active view'), distinguishing it from sibling tools like list_revit_views (which lists views) and get_revit_view (which likely retrieves a specific view by ID).

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 need info about the active view—but does not explicitly state when to use this tool versus alternatives. No exclusions or alternative suggestions are given, so guidance is only implicit. For a tool with clear sibling distinctions, explicit advice would elevate this to 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'get comprehensive information' without indicating whether the operation is read-only, what data is included, or any potential side effects. The description does not contradict annotations since there are none, but it fails to provide 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, concise sentence that is easy to parse and front-loads the verb and resource. No unnecessary words are present, making it appropriately sized for a zero-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?

Given the lack of annotations, output schema, and parameter details, the description is too vague to be considered complete. It says 'comprehensive information' but does not specify what that includes, which is particularly problematic for an AI agent needing to decide whether to invoke this tool or a more specific sibling like list_revit_views or get_current_view_info.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics because there are none to document.

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 'Get' with the resource 'current Revit model', clearly indicating this tool retrieves model information. It distinguishes itself from sibling tools like get_current_view_info and get_revit_status by focusing on the model rather than views or status, though 'comprehensive information' is somewhat vague 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 on when to use this tool versus alternatives. There is no mention of preferred scenarios, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name and 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?

There are no annotations, so the description carries the full burden. It discloses that the tool checks liveness, implying a read-only operation, but does not mention side effects (likely none) or the exact nature of the response. Given the simplicity of a status check, this is adequate but not rich in behavioral detail.

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 adds value, stating the exact purpose in a compact form.

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 (0 params, no output schema), but the description does not specify what the return value will be (e.g., a boolean or status message). For a status check, this is likely sufficient, but given no output schema, it would be more complete to briefly indicate the expected response format.

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 input schema is empty. The description does not need to explain parameters, and the schema coverage is trivially complete. Baseline for 0 params is 4, and no extra semantics 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 'Check if the Revit MCP API is active and responding' clearly states a specific verb ('check'), resource ('Revit MCP API'), and desired outcome (active/responding). It distinguishes from siblings like get_revit_security_status (security-specific) and get_revit_model_info (model info), making its purpose unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives is given. However, the purpose is clear enough that an agent would infer it as a pre-flight health check before making other Revit API calls, but the description does not state this relationship or exclude any sibling 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 must carry the full burden of behavioral disclosure. It only states the action without mentioning output format, side effects, required permissions, or whether the view must be active. This lack of detail fails the 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, focused sentence that directly communicates the tool's purpose without any unnecessary words 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?

For a tool with no output schema and no annotations, the description is too minimal. It does not clarify what the agent should expect in response (e.g., image data, file path) or any prerequisites, making it incomplete 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?

The schema has a single required parameter 'view_name' with no description (0% coverage). The tool description does not elaborate on how to specify the view, such as exact name matching or case sensitivity, leaving parameter semantics entirely to the schema's minimal definition.

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 'Export a specific Revit view as an image' clearly states the action (export), the resource (a specific Revit view), and the output (an image). It distinguishes itself from sibling tools like list_revit_views by specifying the export behavior.

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 tool is used when an image of a specific view is needed, but it does not explicitly mention prerequisites, alternatives, or when not to use it. Sibling tools like list_revit_views suggest a workflow, but no guidance is provided here.

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

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

With no annotations provided, the description carries the full burden of disclosure. It reveals important behaviors: automatically finding installed versions, polling the pyRevit Routes health endpoint, and showing a worksharing dialog for central models. However, it does not mention return values, error handling, or behavior when a version is invalid, leaving some gaps.

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 well-structured and front-loaded. The first sentence states the core purpose, followed by concise behavioral notes, a paragraph on worksharing with an alternative, and a clear parameter list. Every sentence adds value without repetition or padding.

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

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

The description covers the main workflow and parameters, but without an output schema it does not explain what the tool returns (e.g., success message, launched version, errors). It also omits edge cases like multiple installed versions or already-running instances. Given the tool's complexity and lack of structured metadata, some crucial information is missing.

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

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

The input schema has zero descriptions for its parameters, so the description's Args section fully compensates. It explains file_path extensions (.rvt, .rfa, .rte), version as a year with 'Uses latest if omitted,' language as a code with examples, and timeout as seconds with a default of 120. This adds crucial meaning beyond the bare schema.

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

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

The description opens with 'Launch Revit on this machine, optionally opening a file,' which clearly states the action and resource. It further distinguishes itself from sibling tools like open_document by explaining the launch and readiness-check behavior, making the tool's specific role unmistakable.

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 explicitly directs users to 'Use the open_document tool after launch for more control over worksharing options like detach from central,' providing a clear alternative for a specific scenario. It also explains the automatic version discovery and readiness polling, giving context on when this tool is 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?

No annotations are provided, so the description carries full burden. It clearly indicates a read-only operation (listing parameters) with no side effects, but does not explicitly state read-only, auth needs, or rate limits. The description is sufficient for a benign query 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 clear and well-structured with a purpose line, a contextual note about coloring, and an Args/Returns section. It is concise but could be slightly tighter by removing redundancy between the first sentence and the later note.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description provides adequate context: it explains what the tool returns (list of available parameters with types and sample values) and gives an example input. It is sufficiently complete for an agent to understand and invoke the tool.

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

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

Schema description coverage is 0%, but the description adds meaning with 'Name of the category to check parameters for (e.g., 'Walls', 'Doors')', which provides context and examples not present 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 tool 'Get available parameters for elements in a category' and specifies it helps discover parameters for coloring. The verb 'list' and resource 'parameters' are specific, distinguishing it from siblings that list families or categories.

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 needing parameters for coloring but does not explicitly state when to use or not use this tool versus alternatives like ai_element_filter or set_parameter. No exclusions or alternative tools 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 provided, so description must convey behavioral traits. It indicates a read operation ('get') but doesn't disclose side effects, required document state, or pagination behavior. Lacks depth needed to fully inform safe invocation.

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

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

Two sentences, no filler. First sentence states purpose, second gives actionable usage hint. Efficient and front-loaded.

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

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

Covers basic functionality and filter option, but lacks output format details, prerequisites (e.g., open document), and explanation of 'limit' parameter. Adequate but leaves gaps for an 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?

Schema description coverage is 0%, so description must compensate. It explains the 'contains' parameter well (filter by substring, case-insensitive) but does not explain 'limit' parameter (default 50, role unclear). Partial compensation.

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

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

Clearly states it gets a flat list of family types in the Revit model, specifying the resource (family types) and action (get). Differentiates from siblings like list_family_categories by focusing on types rather than categories.

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

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

Provides guidance on using the 'contains' parameter for filtering with case-insensitive substring match, but does not mention when to use this tool versus alternatives like list_family_categories or any prerequisites.

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 burden. 'Get' implies a read-only operation with no destructive side effects. The description does not elaborate on performance, return size limits, or whether the list is static or dynamic, but for a simple retrieval, this is acceptable.

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 directly states the tool's function with no extraneous words. It is front-loaded and efficient.

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

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

Given the tool has no parameters and no output schema, the description is largely sufficient. It could optionally mention that the return is a list of category names or IDs, but the current lack of detail does not hinder understanding for a simple read action.

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

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

The input schema has no parameters and schema coverage is 100%. The description does not add extra semantics beyond what the schema already conveys (i.e., nothing to configure). Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('all family categories in the current Revit model'). It distinguishes from siblings like list_families (which returns families, not categories) and list_category_parameters (which returns parameters of a category).

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide usage examples or prerequisites. However, the tool's simple nature and clear purpose imply its usage context without needing extra guidance.

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

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

With no annotations, the description alone must disclose behavioral traits. It only states the action, not the return format, side effects, or safety profile. The read-only nature is implied by 'Get' but not stated explicitly.

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

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

The description is a single, concise sentence that front-loads the verb and resource. Every word contributes to clarity with no redundancy.

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

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

Given the tool's simplicity (no parameters, no output schema), the description adequately conveys what it does and what it returns. It could mention the return format, but 'list of all levels' is sufficiently informative.

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 accepts zero parameters, so there is no parameter ambiguity. The description confirms that the list is unfiltered, which is sufficient for a no-argument tool.

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

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

The description uses a specific verb 'Get' and a clear resource 'all levels in the current Revit model', distinguishing it from sibling tools that list views, families, or categories.

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

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

It clearly states the context (current Revit model) and implies the tool is for retrieving levels rather than other entities. However, it does not explicitly mention alternatives or when not to use it.

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

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

No annotations are provided, so the description must carry the behavioral disclosure. It does so by stating that it 'returns a list' and implying a read-only discovery operation. It does not elaborate on edge cases or performance, but it is sufficient for a simple list 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 three concise sentences, front-loading the purpose and return value, with no redundant information.

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

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

This simple tool requires no inputs and has no output schema; the description explains what it returns and when to use it, making it complete.

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

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

The input schema has no parameters, and the description correctly avoids parameter information. Baseline is 4 for 0-parameter tools.

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 'Discover all Revit versions installed on this system' and specifies the return value as 'installed Revit versions with their executable paths,' making the tool's function unambiguous and distinct from 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 sentence 'Use this to check what's available before calling launch_revit' provides explicit usage context, though it does not explicitly mention 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?

With no annotations, the description must disclose behavioral traits, but it only specifies that it lists exportable views. It does not clarify what 'exportable' means, what data is returned (names, IDs, types), whether a document must be open, or any potential side effects or limitations.

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 that conveys the essential purpose without any filler. Every word contributes to understanding the tool's function.

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

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

While the tool is simple (no params, no output schema), the description could still mention what fields appear in the returned list (e.g., view names, IDs, types). It also doesn't note that this is read-only or state prerequisites like an open Revit document. Missing these details leaves some ambiguity.

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

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

The tool has zero parameters, so the schema fully covers parameter information. The description correctly indicates a simple no-argument call; there is nothing missing.

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 'Get a list of all exportable views in the current Revit model' uses a specific verb ('Get a list') and resource ('exportable views') while scoping to the current model. It clearly distinguishes from siblings like get_revit_view (which likely returns a single view) and get_current_view_info.

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 alternative listing tools like list_levels or list_families, or when not to use it. The description is purely a statement of functionality with no contextual usage advice.

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 for behavioral disclosure. It clearly explains the detach option's effect ('Preserves worksets but severs the link to the central model') and the audit option's purpose. It does not mention potential errors or side effects like closing the current document, but it provides meaningful behavioral context beyond a simple 'open' action.

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

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

The description is concise and well-structured: a lead sentence stating the main purpose, one supporting line about workshared files, and a neatly formatted Args block with per-parameter details. Every word contributes value, no fluff or redundancy.

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

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

For an open-document tool with no output schema, the description covers essential context: file types, detach/audit behaviors, and prerequisite ('running Revit'). It omits edge-case behavior (e.g., what happens if the file is already open, or error handling) but is sufficiently complete for most usage scenarios.

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

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

The input schema has no descriptions (0% coverage), but the description compensates with detailed explanations for each parameter: file_path (absolute path to specific extensions), detach (boolean, detaches from central), and audit (boolean, checks corruption). This goes well beyond what the schema provides, giving the agent complete understanding of each argument.

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

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

The description clearly states the tool's purpose: 'Open a Revit document file in the running Revit instance.' It specifies supported file extensions (.rvt, .rfa, .rte) and distinct options (detach, audit), making it easy to distinguish from sibling tools like close_document or save_document.

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

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

The description implies when to use the tool (when needing to open a Revit file) but does not explicitly compare it to alternatives or mention exclusions. It notes 'in the running Revit instance,' which hints that Revit must be running, but it does not direct to launch_revit if it isn't. No explicit when-not-to-use instructions.

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

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

With no annotations, the description must disclose behavioral traits. It states a create action but omits side effects (e.g., whether coordinates are relative, if active view matters, or if duplicate instances are allowed). This is insufficient for an agent to predict behavior.

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 12‑word sentence, which is concise but too sparse for 8 parameters. While front‑loading is good, it omits necessary details, making it marginally adequate.

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 8 parameters, no output schema, and no annotations, the description is incomplete. It does not explain required vs optional behavior, coordinate semantics, or the 'properties' object. The agent would need to guess many 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%, so the description must compensate. It does not explain any parameter (e.g., family_name meaning, coordinate system, or properties object). The parameter names are self‑descriptive but the description adds no extra meaning, leaving gaps.

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 ('place') and resource ('family instance') and mentions the action occurs at a 'specified location in the Revit model'. It clearly distinguishes from sibling tools like 'list_families' (which lists) and system family creation tools like 'create_duct' or 'create_pipe'.

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 prerequisites (e.g., family must be loaded) or excluding situations (e.g., if family not found). No explicit context or when-not advice is 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly explains the two behaviors (in-place save and Save As) and the condition that triggers each. It does not mention potential side effects like overwriting files or changing the active document path, but the core behavior is transparent.

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

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

The description is compact and front-loaded, with the core purpose in the first sentence. The Args block repeats information already in the narrative, but it is brief and does not detract significantly from readability.

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 tool with one optional parameter and no output schema, the description covers all essential behavior. It could mention file extensions or overwrite behavior, but the current level is sufficient for an agent to use 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 schema provides only a parameter name and type with no description, so the description must compensate. It clearly defines file_path as optional and explains its role in triggering Save As, adding meaningful context beyond 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 uses a specific verb ('Save') and resource ('active Revit document'), clearly distinguishing it from sibling tools like open_document, close_document, or sync_with_central. It immediately communicates the tool's core function.

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 two explicit scenarios based on the presence of file_path: saving in place vs. Save As. This gives clear usage guidance, though it does not mention alternatives or conditions that would make this tool inappropriate.

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 explains the effects of each parameter (comment in the worksharing log, compact central, relinquish borrowed elements/worksets) and states the workshared-only precondition. However, it does not describe error behavior or what happens if the document is not workshared beyond the directive to use save_document.

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

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

The description is concise and well-structured, with a clear opening statement and a neatly formatted Args section. Every sentence contributes useful information, with no redundant or filler content.

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

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

Given the absence of an output schema and annotations, the description covers the essential workflow, all parameters, and usage constraints. It is missing minor details such as return value or explicit error handling, but for a sync operation with this complexity, it is largely complete.

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

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

The input schema has no parameter descriptions (0% coverage), but the description adds meaningful explanations for all three parameters: comment, compact, and relinquish_all, including the default value for relinquish_all. This fully compensates for the schema gap and provides clear semantic understanding.

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 explicitly states the action 'Synchronize the active workshared document with central' and clearly identifies the resource (workshared document). It distinguishes this tool from save_document by noting the workshared vs non-workshared distinction, which is a specific and helpful 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 explicit usage guidance: it only works with workshared documents, and for non-workshared documents, it directs the user to save_document. This clearly states when to use the tool and when to use an alternative, offering strong contextual direction.

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