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

No annotations are provided, so the description carries the full behavioral burden. It discloses an important behavioral trait beyond the obvious creation: the newly created project becomes active. It does not mention failure behavior, what happens to the previously active project, return values, or any prerequisites, which would be needed for full transparency.

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

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

The entire description is one efficient, front-loaded sentence. Every word earns its place: the action, the resource, and the active-project side effect. There is no fluff or 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 is a simple tool with a single parameter, an input schema, and no output schema. The description covers the core operation and activation side effect, but it omits return-value behavior, duplicate-name handling, and interaction with switchProject/listProjects. Given the absence of annotations and an output schema, the description could be slightly more complete for an agent to predict the result of a call.

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 touches on the 'name' parameter beyond implying it is the project name. The schema already exposes the parameter and its regex pattern, so the description adds no new semantic meaning for the single parameter. Since coverage is low, the description was expected to compensate but does not.

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

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

The description opens with a specific verb and resource: 'Create a new build project.' It goes on to state a key side effect, 'and make it active,' which clearly differentiates this tool from siblings like listProjects, switchProject, and deleteProject. An agent can immediately understand what the tool does and how it differs from the project-related 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 gives clear usage context: use createProject when you need a new build project. It implicitly distinguishes from switchProject by emphasizing creation and activation. However, it does not explicitly name alternatives or state when not to use this tool, so it stops short of the highest bar.

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. 'Build a cylinder' implies a world-modifying action but reveals nothing about side effects, whether it replaces blocks, how hollow behaves, orientation, permissions, 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 blurb is short and scannable, but this is under-specification rather than effective conciseness for a tool with a nested five-parameter schema. A single three-word sentence does not satisfy the need for informative structure.

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 complexity of the schema — nested center objects, weighted block alternatives, optional hollow — and the total absence of annotations or output schema, this description is not nearly complete. An agent is left without crucial semantics about coordinate meaning, cylinder orientation, block selection behavior, or return value.

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 for any of the five parameters. The schema provides types and requiredness, but the description does not explain center, radius, height, hollow, or the weighted block array semantics, so it fails to compensate for the coverage 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 uses a specific verb, 'Build', and a specific resource, 'cylinder', so the agent knows the basic operation. However, it does nothing to distinguish this tool from sibling tools like sphere, wall, line, or fillBox beyond the resource name.

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 sphere, fillBox, or wall. No exclusions, prerequisites, or context are given, leaving the agent to infer usage entirely from the schema and 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 full behavioral burden but only states that deletion occurs. It does not disclose whether deletion is permanent, affects associated builds, or requires confirmation.

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 four-word sentence conveys the entire purpose without waste. The structure is optimally compact 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?

For a destructive operation with no output schema or annotations, the description provides the bare minimum. It lacks information about permanence, related data, and error conditions, making it incomplete for an agent deciding how to 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?

Schema coverage is 0% and the description does not mention the 'name' parameter at all. Although the parameter name is intuitive, its meaning (exact name vs. ID) is not 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 uses a specific verb (Delete) and resource (build project), making it immediately clear what the tool does. This distinguishes it from sibling tools like createProject or switchProject by the action itself.

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

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

No guidance is given on when to use this tool versus alternatives, nor are any prerequisites or side effects mentioned. The description only states the action, leaving the agent to infer 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 must carry the burden of behavioral disclosure. It does disclose the output path, the returned absolute path, and project-name constraints, which is useful. However, it does not state whether an existing output file is overwritten, whether the export modifies the active project, or what happens if no project is active.

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 with no filler. The primary action and destination are front-loaded, and the project-name constraint is provided as a separate concise clarification. Every sentence 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 description covers the essential output location and return value, but omits behavior around file overwrites and the requirement that an active project must exist before calling. Since there are no annotations and no output schema, these are meaningful gaps for an agent choosing whether to 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?

The tool has zero parameters and the schema is an empty object, so the baseline is 4. The description adds relevant context by specifying allowed characters in project names, which helps the agent understand what project names may appear in the output path. No parameter documentation is needed beyond this.

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 ('Export'), a specific resource ('the active project'), a concrete destination ('./output/<projectName>.schem'), and the return value ('absolute path'). This clearly distinguishes it from siblings like listProjects, createProject, or setBlock.

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

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

The intended use is implied by the verb 'Export' and the context of an active project, but no explicit when-to-use guidance or exclusions are given. There are no sibling export tools, so the lack of alternatives is somewhat mitigated, but the description still does not say 'use this when you need to save the current schematic'.

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. 'Fill' implies a mutating operation, but the description does not disclose whether existing blocks are replaced, whether the operation is reversible, how it interacts with the current project, or any limits on size. These behavioral traits are uncovered.

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 six-word sentence with no redundant or extra information, making it highly concise and easy to scan. It front-loads the verb and object, though the extreme brevity limits its content value.

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 three required nested parameters, no output schema, and no annotations, a one-sentence description is far from complete. It omits coordinate semantics, whether bounds are inclusive, block property syntax, and the weighted block list behavior, leaving too much 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?

Schema description coverage is 0%, so the description must compensate, but it does not explain the roles of 'from', 'to', or 'block'. An agent would have to infer that from/to are corner coordinates and block is the fill material, and the weighted array variant is completely 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 states a clear action ('Fill') applied to a specific resource ('solid rectangular box'), which conveys what the tool does. It does not explicitly distinguish from sibling tools like outlineBox or wall, but the shape and 'solid' qualifier imply 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 use fillBox versus sibling tools such as setBlocks, outlineBox, wall, or line. No conditions, prerequisites, or alternatives are mentioned, leaving the agent to guess 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 the burden of indicating safety and behavior. 'Get' plus the listed read-only fields strongly implies a non-mutating operation, and the description states exactly what is returned. It does not discuss auth or absence of an active project, but for a zero-parameter getter this is 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 an immediate verb-resource pair and a compact parenthetical list of returned content. Every part earns its place 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?

For a no-parameter read tool, the description adequately covers the resource, the active-project context, and the output fields. It does not explain how the active project is determined or what happens if none exists, but that goes beyond the minimum needed for safe 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 tool has zero parameters, so there are no parameter semantics to augment. Per the rubric, a zero-parameter tool earns a baseline of 4, and the description adds no unnecessary parameter-related detail.

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' with the resource 'active project' and enumerates the returned information (size, bounding box, block counts). This clearly distinguishes it from sibling tools like listProjects and switchProject, which focus on project listing or selection rather than summary metrics.

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 identifies the target context ('active project') and the nature of the data (summary), so when to use it is implied. However, it does not explicitly contrast it with alternatives or mention when not to use it, leaving some guidance to inference.

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

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

With no annotations, the description carries the full burden of explaining side effects, but it only says blocks are drawn in a line. It does not disclose whether existing blocks are overwritten, how the weighted block array is resolved, or if endpoints are included.

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 core behavior and is appropriately sized for a straightforward drawing tool.

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

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

For a mutating tool with no annotations and no output schema, this is incomplete: an agent is left to infer overwrite behavior, coordinate conventions, and how the block parameter's variants behave. The terse description does not provide enough context for confident invocation in a block-editing 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 should compensate for the schema's silence, but it only glosses over the parameters as 'two points' and 'blocks'. It does not explain that block can be a single object or a weighted array, nor add meaning to the from/to coordinates.

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 ('Draw') and a distinct resource ('straight line of blocks') between two endpoints, which separates it from sibling shape tools like fillBox, wall, and sphere. It clearly maps the main intent to the from/to/block parameters.

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 alternatives such as setBlocks, wall, or fillBox. The description only states what the tool does, not the conditions that make it the right choice.

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 convey that the tool is a read-only listing operation and that the result is project names, which is useful. However, it does not disclose return format, empty-list behavior, authentication requirements, or other potential 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, efficiently worded sentence that front-loads the action and scope. Every word adds meaning and there is no redundant or filler content.

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

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

For a zero-parameter list tool, the description is nearly complete: it states the action, the scope ('all'), and the output type ('names'). It could be slightly more explicit about the return shape, such as 'returns an array of strings', but the simplicity of the tool makes the current description sufficient.

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, so there are no parameter semantics to clarify. The description appropriately does not mention parameters, and the baseline score of 4 applies.

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

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

The description uses a specific verb, 'List', and identifies the exact resource, 'all build project names'. This clearly distinguishes it from sibling tools like createProject, deleteProject, and switchProject without needing to inspect 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 intended usage is implied: use when you need the names of all build projects. However, there is no explicit guidance about when to prefer this over alternatives, when not to use it, or what to do if the list is empty. It is adequate but leaves the agent to infer 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 must carry the full behavioral disclosure burden. It only states the result shape and omits details such as coordinate interpretation, block replacement behavior, scope, or 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, front-loaded sentence with no filler or unnecessary detail. It is concise, though it sacrifices valuable parameter and context information.

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

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

For a tool with three required nested parameters, no annotations, and no output schema, one sentence is insufficient. Missing details about corner semantics, block format, and build behavior make the description 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?

Schema description coverage is 0%, and the description does not explain what from, to, or block mean. The agent cannot determine that from/to are likely corner coordinates or that block may be a weighted list.

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 ('Build') and a clear resource ('hollow rectangular box (shell only)'). It distinguishes the tool from the sibling fillBox by emphasizing hollowness and shell-only output.

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

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

There is no explicit guidance about when to use this tool versus alternatives like fillBox, wall, line, or sphere. Usage context is only weakly implied by the word 'hollow' and the 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?

No annotations are provided, so the description carries the full burden of disclosure. 'Set' implies a mutating operation, but the description does not state whether existing blocks are overwritten, whether changes are reversible, what happens with invalid block IDs, or what the response/error behavior is.

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 redundancy. It communicates the operation and scope efficiently, and 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 no annotations, no output schema, 0% schema description coverage, nested parameters, and many sibling tools, this one-liner is under-specified. It leaves out essential invocation context such as coordinate semantics, block data format, active-project requirements, and how it relates to batch operations like setBlocks.

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 beyond the names already present. It does not explain the coordinate system for pos, the expected format of block.id, or the purpose of the optional properties map, so it fails to compensate for the schema's lack of 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?

Description uses a specific verb ('set') plus resource ('block'), and explicitly narrows scope to 'a single block in the active project.' This clearly distinguishes it from the sibling tool setBlocks, which implies bulk operation. An agent can understand the tool's core purpose 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 gives no guidance about when to use this tool versus setBlocks, fillBox, wall, or other block-manipulation siblings. The word 'single' implies one-block usage, but there are no explicit alternatives, exclusions, or conditions.

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 disclosing behavior. It indicates the operation modifies blocks but does not explain overwriting semantics, whether changes are applied atomically, what happens if the project is not active, or what the return value/error behavior is. For a mutation tool, this is a substantial 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, direct sentence with no wasted words, and the core action is front-loaded. It is concise and easy to parse, though the content is thin.

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 this is a batch mutation tool with no annotations, no output schema, and one complex parameter, the description does not provide enough context for reliable use. Missing details include coordinate system, block replacement behavior, failure semantics, and relationship to sibling block-placing 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 description coverage is 0%, and the description adds only that multiple blocks are set. It does not explain the meaning of pos, block, id, or properties beyond their names. The schema provides structural shape but very little semantic guidance, and the description does not compensate.

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 and resource: set multiple blocks in the active project. The plural 'blocks' and 'in one call' help distinguish it from the sibling setBlock, though it does not explicitly name alternatives.

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

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

The description implies this tool is for setting several blocks at once, which is useful context. However, it does not state when to prefer this over setBlock, fillBox, wall, or similar tools, nor does it provide any exclusions or 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 the full burden of behavioral disclosure. 'Build a sphere' only implies a mutation of some kind and does not mention whether it overwrites existing blocks, how hollow behaves by default, or what side effects occur.

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 short, but this is under-specification rather than conciseness. The single sentence provides almost no useful structure or front-loaded guidance for an agent.

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 four parameters, nested objects, no output schema, and no annotations, this definition is severely incomplete. The agent is left to infer coordinate handling, block semantics, destructive behavior, and return values entirely from the raw schema.

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 contributes no parameter-level meaning. It does not explain that block can be a single block or a weighted distribution, what hollow means, or how center and radius are interpreted.

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 merely restates the tool name with a generic verb. It gives no information about what kind of sphere, whether it is filled or hollow, or how it relates to sibling tools like cylinder, fillBox, or setBlocks.

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 alternative shape-building tools. The description does not state prerequisites, expected context, or exclusions, so an agent cannot judge when sphere is the correct choice.

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 that the active project changes but does not mention whether this is persisted, whether it affects subsequent build operations, or whether it has side effects like requiring saved state. For a state-changing tool, this is insufficient transparency.

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, with no filler or redundant wording. It front-loads the core action immediately. The brevity is appropriate for such a simple tool, though the lack of additional context prevents a perfect score.

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 and output schema, the description is too sparse to be considered complete. It does not explain prerequisites, side effects, failure modes, or what happens to current state when switching projects. An agent would likely need to consult other tools or documentation to understand the full operational context.

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 beyond the parameter name 'name'. It is likely clear that 'name' refers to the target project name, but the description does not explicitly state that, nor does it clarify whether it is a display name, ID, or exact match. With low schema coverage, the description should compensate but does not.

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

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

The description uses a specific verb ('Switch') and resource ('active build project'), which clearly conveys the tool's function as changing the currently selected project. It is distinct enough from siblings like listProjects, createProject, and deleteProject that an agent can infer this is not creating or deleting. However, 'active build project' is somewhat vague and could be clarified further.

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 does not mention that this should be used only with existing projects, nor does it explain any relationship to listProjects or getBuildInfo. The agent is left to infer usage context from the sibling tool 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, the description carries the full burden of behavioral disclosure, but it only restates the high-level action. It does not say whether the wall is solid, how 'vertical' is interpreted in world coordinates, whether existing blocks are replaced, or what side effects occur.

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: the verb and object appear immediately. It is concise, though the brevity omits context that other dimensions need.

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 four required parameters, nested object structures, no annotations, and no output schema, the description is too thin to fully guide invocation. It leaves unstated the orientation convention, block parameter format, and height semantics that an agent would need 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?

Schema description coverage is 0%, and the description adds no meaning for from, to, height, or block. The phrase 'between two points' loosely maps to from/to, but it does not explain coordinate roles, the meaning of the height value, or that block can be a single block or a weighted list.

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 ('Build') and a clearly identifiable resource ('a vertical wall along the line between two points'), which distinguishes it from sibling shape tools like line, sphere, and cylinder. It does not explicitly name or contrast those siblings, so it misses the top score.

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 wall versus line, fillBox, outlineBox, or the other shape tools. No prerequisites, exclusions, or alternative-selection conditions are provided.

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