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 conveys that the tool is a read-only informational retrieval ('Get') and specifies the content categories. It does not describe output format, but for a simple cheatsheet lookup this is mostly sufficient.

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 information. Every word contributes to telling the agent what the tool returns.

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 informational tool, the description is nearly complete: the agent knows what to call and what content to expect. It lacks explicit details about return format or version coverage, but those are not critical for selecting or invoking this tool.

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

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

The tool has zero parameters and the schema is empty, so there are no parameter meanings to document. Per the zero-parameter baseline, a score of 4 is appropriate; the description adds no parameter information because none is needed.

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 ('Get') and the resource ('OpenSCAD language cheatsheet'), and enumerates the content scope: primitives, transformations, and tips. It is easily distinguished from the sibling tools, which are all rendering, export, validation, or file-reading 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?

The description gives no guidance about when to use this tool versus alternatives, and no explicit when-not-to-use conditions. It is only implied that it is for language reference material, but there is no direct routing or exclusion information.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It does state the output behavior ('Returns the file path') and lists formats, but it does not disclose whether files are overwritten, where they are written, or any error/validation 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 extremely concise: two sentences, no redundant phrasing, and the primary purpose is front-loaded. It earns its place without excess 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 four parameters including a nested object and no output schema, the description is somewhat thin. It covers the return value and basic file types, but omits the purpose of 'params', filename behavior, and any side effects or prerequisites.

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

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

Schema coverage is 75%, so the schema documents most parameters, but the description adds no parameter-level meaning. Notably, the 'params' object has no schema description and is not mentioned at all, leaving a gap for a key nested parameter.

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 resource ('OpenSCAD code to a 3D file'), and lists common formats. It clearly identifies the tool's core function, though it does not explicitly contrast with sibling tools like render or validate.

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 render or validate. It does not mention when export is preferable or what conditions might require a different tool.

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 adequately indicates a read-only informational operation and specifies the output's key content (WASM vs native). It does not elaborate on side effects, but the operation is inherently non-mutating and the description covers the main behavioral trait.

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

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

A single, clear sentence with no filler. The operation and its core output are stated compactly and front-loaded. Every word earns its place.

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

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

The tool is minimal: no parameters, no output schema, and no complex behavior. The description fully covers what an agent needs to know to invoke it correctly and interpret the result, identifying the engine type as WASM or native. There are no missing details that would affect correct usage.

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 correctly focuses on behavior rather than parameters, and since there are no inputs, no parameter-specific guidance is needed.

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 'Check' and names an explicit resource: 'OpenSCAD engine info' with the two possible values '(WASM or native)'. This clearly differentiates it from sibling tools like render, export, or validate, which perform model operations rather than returning engine information.

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—whenever engine type information is needed—but it does not explicitly state when to choose it over alternatives or mention any exclusions. For a simple info-gathering tool this context is largely self-evident, but no explicit guidance 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?

With no annotations provided, the description carries the behavioral disclosure burden, and it does well by surfacing the important runtime limitation that libraries only work with native OpenSCAD, not the bundled WASM engine. This is more than a restatement of the tool's name. It doesn't detail the exact output format, but 'List' strongly implies a read-only enumeration.

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

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

Two concise sentences, with the core purpose front-loaded and the critical compatibility caveat in the second sentence. No filler, no redundant phrasing.

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 this is a simple zero-parameter read-only list operation, the description is adequate: it names the resource, states what it does, and flags an important environment-specific behavior. It could add what the output looks like or when it might be empty, but for such a low-complexity tool the current description covers the essential decision and expectation-setting information.

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 description doesn't need to document any arguments. The schema already shows an empty properties object, and the description appropriately adds no parameter noise.

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

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

The description uses a specific verb ('List') and resource ('installed OpenSCAD libraries'), clearly identifying what the tool does. The caveat about native OpenSCAD vs the WASM engine also helps distinguish it from the rendering/exporting 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?

It gives clear context for when to use the tool: when you need to know which libraries are installed. The note about libraries not working with the WASM engine also tells agents when results may not be meaningful, though it doesn't explicitly name alternative tools 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 provided, the description carries the behavioral disclosure burden. It states the side effect of opening a browser viewer, the dependency on a previously rendered model, and the rotate/zoom/pan controls. It does not mention what happens if no model has been rendered yet, 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?

Two short sentences front-load the action and then add the relevant behavioral detail. There is no redundant wording, and every clause contributes useful information about what the tool does and what the user can do in the viewer.

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, zero-parameter browser-viewer tool, the description covers the action, the content shown, and the available interactions. The only notable omission is an explicit statement about prerequisites or error behavior when no model has previously been rendered.

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 properties, so there are no parameter semantics to document. The description reinforces the no-input nature by referring to 'the most recently rendered model' rather than any user-supplied argument, which earns the baseline score for a zero-parameter tool.

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

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

The description opens with a specific verb and resource: 'Open the interactive 3D viewer in the browser.' It then clarifies what the viewer shows and how the user can interact. This clearly distinguishes it from rendering/export sibling tools by focusing on browser-based viewing rather than producing render outputs.

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: the viewer shows 'the most recently rendered model,' so an agent can infer this tool is used after a render operation to inspect the result. It does not explicitly name alternatives or state when not to use it, but the context is sufficient for a zero-parameter tool.

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 states that the tool reads a file from disk, but does not disclose whether this is a safe read-only operation, how missing files or invalid paths are handled, or what the response looks like. The behavioral context is too thin for an agent relying solely on the description.

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, direct sentence with no filler. It front-loads the action and resource, making it easy for an agent to parse quickly. Every word earns its place.

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

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

Given that there are no annotations and no output schema, the description should explain return values and invocation context more fully. It specifies the required path parameter but does not tell the agent what it receives after the read, how errors surface, or when this is the right tool among the siblings. The description is minimal but leaves important gaps.

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

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

The input schema already provides full coverage for the single 'path' parameter, including a description ('Absolute path to the .scad file'). The description adds no additional parameter-level meaning, but since schema coverage is 100%, the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Read') and resource ('OpenSCAD (.scad) file from disk'), which clearly distinguishes it from sibling tools like render, export, or validate. It does not specify whether the tool returns the raw file contents or a parsed representation, but the verb and resource are unambiguous enough for basic selection.

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 scenarios where read_scad_file is preferred over render, validate, or open_viewer, leaving the agent to infer when file reading 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?

With no annotations, the description carries the behavioral disclosure burden. It explicitly states what is returned ('Returns the image inline') and the side effect on the live viewer, which is useful context beyond the schema. It does not mention potential failure modes or performance characteristics, but the core side-effect disclosure is 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 two concise sentences, with the core action first followed by the key behavioral details. There is no redundant or filler content.

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

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

A preview-render tool with no output schema is adequately covered by the statement that an inline image is returned, and the schema covers all parameters. The main completeness gap is the absence of when-to-use guidance relative to the rendering-focused 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 100%, and the schema already documents all six parameters, including the camera format and default dimensions. The description adds no parameter-level meaning, which matches the baseline of 3 when the schema does the heavy lifting.

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 and resource: 'Render OpenSCAD code to a preview image,' which is clear and not a tautology. It does not explicitly differentiate from sibling rendering tools such as render_turntable or render_multiview, so it stops short of a 5.

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 alternatives like export, validate, render_turntable, or render_multiview. The only contextual hint is the viewer-update side effect, which does not help an agent choose among rendering variants.

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 communicate the key output characteristic (a single grid image) and notes the default view set, which is useful. However, it does not mention potential side effects (if any), error behavior, output format details, or execution context such as whether the input code must be valid OpenSCAD.

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 core idea front-loaded and a useful parenthetical clarifying the default view set. There is no wasted 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?

For a tool with five parameters, a nested object, no output schema, and no annotations, this description is too sparse. It does not explain how 'params' should be used, what the return output actually is beyond 'grid image', or how it relates to siblings. An agent would likely need additional inference to use all capabilities correctly.

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

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

Schema description coverage is high (80%), and the description adds no detailed parameter semantics beyond what the schema already provides. It does reinforce that 'views' typically includes front, right, top, and perspective, but the 'params' nested object remains unexplained by both 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 states a specific verb ('render') and a resource ('multiple views of the model in a single grid image'), and even enumerates the default views. This makes the tool's function clear and somewhat distinguishes it from siblings like 'render' and 'render_turntable', though it does not explicitly contrast them.

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 alternatives such as 'render' or 'render_turntable'. The name and description imply a grid of multiple views, but no exclusions or alternative routing 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the return behavior ('Returns an animated image (APNG) inline'), which is meaningful. However, it does not mention rendering time, potential side effects, failure modes, or whether the input code is modified or just read, leaving some behavioral ambiguity.

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

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

The description is extremely concise: two sentences with no filler. It front-loads the core purpose in the first sentence and adds the key output detail in the second. Every word earns its place.

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

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

For a tool with no output schema and no annotations, the description gives the essential purpose and return type but leaves gaps. The nested 'params' object is completely unexplained, which could be important for passing OpenSCAD variables. Still, the core calling pattern is clear: provide OpenSCAD code and get turntable APNG, so it is minimally viable.

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 80%, so the baseline is 3. The description adds no additional parameter meaning beyond the schema. It does reinforce that 'frames' relates to a 360° turntable animation, but this is a minor enhancement over the schema's own 'Number of frames (default 24)' 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 ('Render a 360° turntable animation of the model') and identifies the exact output ('animated image APNG inline'). This distinguishes it from sibling tools like render or render_multiview because it uniquely specifies the turntable animation format, so an agent can select it correctly without opening the schema.

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

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

The description implies usage: when you need a 360° turntable animation, this is the tool. It also mentions the inline APNG return, which hints at how the output will be consumed. However, it does not explicitly contrast with sibling tools like render or render_multiview, nor does it state 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?

With no annotations provided, the description itself carries the behavioral burden. It clearly discloses that the tool performs only syntax checking, skips full rendering, and is fast, which conveys a non-destructive, lightweight validation behavior. It could add explicit output/error details, but the core behavioral distinction is 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 compact, front-loaded with the key purpose, and wastes no words. The phrase 'without full rendering' is the key distinction, and 'Fast.' adds a useful performance trait without 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?

For a one-parameter, no-nested-schema tool, the description plus schema provides sufficient information to invoke it correctly and understand its purpose. The main gap is the lack of explicit return/error behavior—there is no output schema and the description does not say what the agent sees when validation fails—but this is a minor gap for a simple syntax checker.

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

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

The input schema already fully documents the single parameter as 'OpenSCAD source code to validate', giving 100% schema coverage. The tool description adds no new parameter details beyond that, so the 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 identifies a concrete verb ('Check'), a specific resource ('OpenSCAD code'), and a clear scope ('syntax errors'). The phrase 'without full rendering' immediately distinguishes it from the render-family siblings, so an agent can tell it apart from render, render_turntable, and render_multiview without opening schemas.

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

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

The description implicitly guides usage by signaling that this is the fast syntax-check path and that full rendering is not performed, which is enough to indicate when to choose it. However, it does not explicitly name sibling alternatives or state when-not-to-use it when a rendered model/view is actually needed.

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