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

With no annotations present, the description carries the full burden of disclosing behaviors. It mentions adding and resaving, implying mutation, but fails to detail crucial aspects such as object_spec validation, error handling, or whether changes are reversible. The description is too sparse to ensure transparent usage.

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

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

The description is a single short sentence, which is concise but overly minimal. It could include more detail without becoming verbose, such as clarifying object_spec format or mentioning output. It is front-loaded but lacks substance.

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 tool (nested object parameter, no schema description, no annotations) and the presence of an output schema, the description is severely incomplete. It does not explain return values, error conditions, or provide any behavioral details beyond the basic action, leaving many gaps for an AI agent.

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

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

The input schema has 0% description coverage, and the description adds no information about the parameters. 'object_spec' is an unconstrained object, and the description does not clarify its expected structure, required fields, or possible values. This leaves agents completely dependent on external knowledge.

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

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

The description clearly states the action ('Add one object to a saved scene manifest and resave it'), using a specific verb and resource. It effectively distinguishes this tool from siblings like 'octane_remove_object' and 'octane_update_object'.

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 only implies usage (when you want to add to a manifest) but offers no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites like the manifest's existence. No exclusions or context for when not to use it 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?

The description provides no behavioral insights. It does not disclose whether the operation is destructive, asynchronous, requires specific permissions, or how queuing works. With no annotations, the description carries full burden and fails completely.

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 but at the expense of clarity. It is too short to convey necessary context, making it under-specified rather than efficiently structured.

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, 0% schema coverage, and an output schema that is not referenced, the description is severely incomplete. It omits all key information needed to use 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 coverage is 0% and the description does not explain the parameters. The required fields object_name and material_name are not described; a user must infer their meaning from the tool name alone.

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

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

The description 'Queue a material assignment command' is vague and nearly tautological with the tool name. It does not specify what 'material assignment' entails or how it differs from siblings like octane_create_material, which might create a new material rather than assign an existing one.

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. There is no mention of prerequisites, typical use cases, or comparisons with sibling tools such as octane_update_object or octane_create_material.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns process state, bridge paths, and heartbeat age, implying a read-only operation. However, it omits any discussion of side effects, authorization needs, or rate limits, leaving gaps in 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 a single sentence with 13 words, front-loading the verb and immediately listing the output items. Every word adds value with zero 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 simplicity (0 parameters, output schema present), the description adequately covers the purpose and return values. It could mention that this is a diagnostic tool for checking bridge process health, but overall it is 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?

There are no parameters (schema coverage 100% by absence). The description adds value by specifying the output structure, which compensates for the lack of parameter documentation. Baseline for zero parameters is 4.

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

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

The description uses a specific verb 'Return' and clearly lists the three types of information returned: Octane X process state, generated bridge paths, and bridge heartbeat age. It distinguishes this tool from sibling tools like octane_status and octane_run_bridge by focusing on bridge process state.

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 (e.g., octane_status, octane_ping). It does not mention prerequisites or context where 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 must disclose behavioral traits. It mentions 'queue' implying async behavior and 'deterministic starter scene commands' but does not explain side effects, destructiveness, auth needs, or whether the tool is idempotent.

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

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

The description is a single sentence and concise, but it lacks crucial details and could be more informative. It is front-loaded but does not fully earn its place due to vagueness.

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 one required parameter, no annotations, and an output schema (not visible), the description is incomplete. It does not explain the output, how to monitor the queued request, or how to interpret results. The agent needs more context to use it effectively.

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% for the single required 'prompt' parameter. The description implies the prompt is a concept description but does not clarify the format, examples, or how it relates to the deterministic starter commands. The agent is left guessing about valid input.

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 queues a concept build request and adds deterministic starter scene commands. It distinguishes from sibling tools like octane_build_planet_scene by specifying 'concept', but it does not explicitly differentiate from other build tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like octane_build_scene or octane_build_product_studio. No prerequisites, exclusions, or context for usage are given.

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

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

With no annotations, the description should disclose behavioral traits. It only says 'Queue', implying submission but not detailing whether it's destructive, reversible, or what side effects occur. No info on permissions or rate limits.

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

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

The description is short (two sentences) and front-loaded with the primary action. However, it sacrifices detail for brevity, missing key parameter info.

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 (2 params, no schema descriptions, no annotations), the description is incomplete. It does not explain the 'overrides' parameter, nor mention the output schema or return values, leaving gaps for the agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'planet' parameter with examples but leaves 'overrides' entirely undescribed, which is insufficient for correct usage.

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 it queues a photoreal planet scene, with specific examples mapping planet values to outputs, clearly differentiating from sibling tools like octane_build_scene or octane_build_product_studio.

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?

While the description implies use for planetary scenes, it does not explicitly state when to use this tool versus alternatives, nor does it provide 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 present, and the description only says 'Queue' without disclosing side effects, permissions needed, rate limits, or what happens to the recipe after queuing. This leaves the agent without essential behavioral information.

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) but sacrifices clarity; it is not front-loaded with critical information and omits necessary details. While short, it does not effectively convey the tool's action.

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 single parameter and absence of annotations, the description is inadequate. It does not explain the output or how the queueing process works, even though an output schema exists.

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

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

With 0% schema description coverage and the description providing no explanation of the 'overrides' parameter, the tool fails to add any meaning beyond the raw schema. The parameter's purpose and usage are completely opaque.

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 'Queue the Photoreal Product Studio recipe' which identifies a specific verb and resource, but the phrase 'as a first-class tool (WP6)' is cryptic and does not clarify the tool's purpose compared to sibling tools like octane_queue_recipe or other build 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?

No guidance is provided on when to use this tool versus alternatives such as octane_queue_recipe or octane_build_concept. The description lacks context for appropriate usage scenarios.

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

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

With no annotations, the description must disclose behavioral traits. It mentions saving a manifest and queuing commands, but omits details like permissions, data persistence, error handling, or whether the operation is destructive. The agent lacks understanding of 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 sentence of 13 words, very concise and front-loaded with the core action. It achieves brevity but could include a bit more context without becoming verbose.

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

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

The tool has a nested object parameter and an output schema, yet the description does not explain what the input should contain or what the output represents. Key information about the plan's format, manifest location, and command queueing behavior is missing.

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

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

Schema coverage is 0% for the only parameter 'scene_plan', and the description does not explain its structure or required fields. The parameter is an object with additionalProperties true, but the description adds no semantic meaning beyond the schema's minimal type and title.

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 builds a semantic scene plan, saves a manifest, and queues validated Octane commands. It uses a specific verb and resource, distinguishing it from sibling build tools like octane_build_concept or octane_build_planet_scene, but does not explicitly differentiate 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?

The description provides no guidance on when to use this tool versus alternatives. It lacks context, prerequisites, or conditions for use, leaving the agent to infer usage solely from the generic verb 'build'.

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 full responsibility for disclosing behavior. It mentions the tool queues a command (suggesting asynchronous operation), creates a node, wires it to the render target, and warns about unsupported pins. However, it omits crucial details such as whether the operation is idempotent, what happens on failure, permissions required, or side effects on existing lights.

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 at two sentences, front-loading the purpose. Every sentence provides necessary context about creation and warning behavior. However, it could be more efficient by integrating parameter explanations without excessive verbosity.

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

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

With 8 parameters, 0% schema coverage, and no annotations, the description is insufficient. The tool has an output schema, but the description does not mention output or return value. The description lacks guidance on parameter semantics and usage context, making it incomplete for an agent to correctly select 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 coverage is 0%, meaning the input schema provides no descriptions for parameters. The description does not explain any parameter beyond implying that light_type can be set via the listed types. For example, 'size', 'angle', 'hdr_path', 'position', 'direction', and 'intensity' are not described at all, leaving an agent with no guidance on their purpose or valid values.

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

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

The description clearly states the action ('Queue a native light creation command') and the resource (light types: area, sun, environment, emissive). It explains the outcome: creates an Octane light/environment node and wires it to the active render target. This distinguishes it from siblings like octane_set_lighting (likely modifies existing) and octane_create_material (creates materials, not lights).

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

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

The description implies usage for creating various light types but does not explicitly state when to use this tool versus alternatives. It mentions that unsupported pins are acknowledged with a warning, but no guidance on prerequisites, exclusion criteria, or comparison with sibling tools like octane_set_lighting or octane_create_test_cube.

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 burden. It discloses key traits: queuing (asynchronous), forwarding of non-default PBR fields, and graceful handling of unavailable pins with warnings instead of crashes. This adds valuable context beyond a simple 'create' statement.

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 very concise: two sentences in the first paragraph and two in the second. Every sentence provides distinct value (purpose, forwarding, error handling). No extraneous 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?

Despite having 13 parameters and 0% schema coverage, the description is only a few lines. It lacks explanations of material kinds, color format, texture paths, or return values (output schema exists but is not referenced). The description is insufficient for an agent to correctly use all parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'optional PBR fields' and the forwarding behavior of non-default values, but does not explain individual parameters (e.g., ior, kind, color) or their expected formats. The agent must rely entirely on parameter names and types, leading to a weak semantic contribution.

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 queues a material creation/update command with optional PBR fields. The verb 'queue' and resource 'material' are specific, and it distinguishes from sibling tools like octane_assign_material by focusing on material definition rather than assignment. However, the dual 'creation/update' may cause slight ambiguity since the tool name only mentions creation.

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. It does not mention prerequisites, conditions for update vs creation, or differentiation from siblings like octane_assign_material. Usage is only implied through the purpose statement.

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 fully disclose behavior. It states queuing occurs, but lacks details on asynchronicity, prerequisites, side effects on existing assets, or the nature of the created OBJ file. The description is minimally adequate but not thorough.

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

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

Single sentence, no unnecessary words. Front-loaded with action and resource. Efficient and to the point.

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, the description covers the core action but omits parameter usage and queues. The presence of an output schema may reduce need for return value explanation, but parameter context is still lacking. Overall adequate but 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 has 0% parameter description coverage, and the description adds no meaning to the 'name' or 'size' parameters. It does not explain how they affect the cube or the import command. The description fails to compensate for the missing schema documentation.

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

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

The description clearly states the tool creates a small OBJ cube asset and queues an import_geometry command. This distinguishes it from sibling tools like octane_add_object or octane_import_geometry, as it combines both creation and queuing of a specific test object.

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. It does not mention scenarios where octane_create_test_cube is preferred over octane_add_object or octane_import_geometry, nor does it exclude certain use cases.

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?

Despite no annotations, the description reveals that the tool does pure offline ranking (keyword, hue-overlap, era), no embeddings, no network. It returns ranked matches with derived_acceptance spec. This is sufficiently transparent for a retrieval 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 concise and well-structured: a one-line summary, a paragraph of behavioral details, and a bulleted parameter list. Every sentence adds value without unnecessary repetition.

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

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

With an output schema present, the description needs only to hint at return values, which it does ('ranked matches...derived_acceptance spec'). It covers purpose, parameters, and behavior adequately for the tool's complexity (4 params, no nesting).

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 was 0%, but the description includes an Args section that explains each parameter in detail: query (with examples), top_k (default 3), domain (with examples of filters), only_converged (boolean condition). This fully compensates for the lack of schema descriptions.

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

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

Description opens with a clear, specific verb+resource: 'find the nearest existing corpus grammar to warm-start a new subject.' It distinguishes itself from sibling tools (which are about building, rendering, etc.) by focusing on retrieval and ranking.

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

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

The description implies usage for initializing a new subject by finding a close prior reference. It notes it's offline and uses specific ranking methods, giving context. However, it does not explicitly state when not to use this tool or mention alternative tools for similar tasks.

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?

Without annotations, the description carries the full burden but only mentions 'Queue' implying asynchronous behavior. No details on idempotency, error handling, permissions, or side effects are given.

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 minimal (one sentence) and fits within typical length, but it omits critical details that would justify its conciseness. It is not front-loaded with the most important 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?

Given three parameters, no annotations, and an output schema, the description fails to explain the command queuing behavior, return value (though output schema may cover it), or any constraints. It is too sparse for effective use.

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%, yet the description adds no parameter-specific information beyond listing file formats. The purpose of 'name', 'path', and 'format' parameters is left entirely to the schema names, which is insufficient for an agent.

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 queues an import command for common 3D geometry formats (OBJ/USD/FBX/Alembic/etc.), distinguishing it from siblings like octane_add_object or octane_create_light which handle different aspects of scene building.

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. The user must infer from the name and context that it is for importing external geometry files, but no exclusions or prerequisites 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?

No annotations provided, so the description carries full burden. It discloses that it returns command sequence and asset paths, but lacks details on side effects, authorization needs, error handling, or behavior on invalid slug.

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

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

Single clear sentence with no wasted words. Front-loaded with action and resource, then specifies included content.

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

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

The tool is simple (single param, output schema present). Description adequately covers input and output content. Could mention error cases or prerequisites, but overall sufficient for a straightforward load operation.

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% (no parameter descriptions in schema). The description adds minimal value by mentioning 'by slug' but does not explain slug format, constraints, or default behavior. Baseline for low coverage is higher, but description fails to 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 clearly states the action (load), resource (checked-in recipe), key identifier (slug), and what is included (command sequence and resolved asset paths). It distinguishes from siblings like octane_queue_recipe and octane_recipe_book.

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

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

The description implies usage for loading a recipe but provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, though sibling tools suggest distinct use cases.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'Load', hinting at a read operation, but fails to confirm safety, permissions, side effects, or error behavior (e.g., what happens if scene_id doesn't exist). This is insufficient for an agent to understand the tool's impact.

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

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

The description is a single sentence, concise and front-loaded. Every word is necessary and no extraneous information is included.

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 has only one parameter and an output schema (reducing need for return value explanation), the description lacks context about what a 'semantic scene manifest' is, how it differs from a regular manifest, and prerequisites. Given the large set of sibling tools, this absence of context makes it hard for an agent to decide when to use 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 description coverage is 0% (no description for scene_id). The description adds only that scene_id is needed, but does not explain its format, origin, or constraints. With such low coverage, the description should compensate but fails to provide meaningful parameter semantics.

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

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

The description clearly states the verb 'Load' and the resource 'saved semantic scene manifest', specifying the key parameter 'by scene_id'. It distinguishes from siblings like 'octane_save_scene_manifest' which is the counterpart for saving.

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 to load a scene manifest given a scene_id, but provides no explicit when-not-to-use, prerequisites (e.g., scene must already exist), or alternatives. It meets the minimum viable threshold but lacks 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 should disclose behavioral traits. It only states the action (queue a ping) but does not describe if it is read-only, what side effects occur, or whether it requires a bridge to be running.

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). It is front-loaded but lacks sufficient detail to be helpful.

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 simple tool with one optional param and an output schema, the description is still too sparse. It fails to explain what a ping does, why one would queue it, or how the output relates to the command.

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 information about the 'message' parameter. The agent cannot infer its purpose or how to use it effectively.

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 queues a ping command for the Octane Lua bridge, specifying the action and resource. However, it does not distinguish from siblings like octane_status or octane_bridge_process_status which might overlap in functionality.

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 other octane tools. There is no mention of prerequisites, typical scenarios, 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 provided, so description must disclose behavior. It only states the action without side effects, permissions, or consequences (e.g., whether queuing overwrites, requires prior steps). Minimal 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?

Single sentence, front-loaded with verb and resource. Efficient but could benefit from bullet points or structured breakdown for clarity.

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 an output schema but no annotations, the description is too brief to fully inform an agent. Key concepts like 'checked-in' and 'recipe command sequence' are undefined, and the overrides structure is ambiguous.

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?

Description adds meaning for the two parameters: 'by slug' clarifies the required slug parameter, and 'optional per-op payload overrides' explains the overrides parameter. However, it does not detail the structure or expected format of overrides, 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?

Description states the action (Queue) and resource (checked-in recipe command sequence by slug) clearly. It uses specific vocabulary that differentiates from siblings like octane_load_recipe or octane_recipe_book, but does not explicitly contrast with 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?

No guidance on when to use this tool versus alternatives. It does not mention prerequisites, contexts, or cases where this tool is 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, the description carries the full burden. It indicates a read operation but lacks details on side effects, idempotency, or output characteristics. The description is minimal.

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

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

The description is a single sentence of 12 words, concise and to the point. There is no wasted text, though it lacks 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 simplicity of the tool, the description covers the basic purpose but omits important details about the parameter and output. The existence of an output schema does not excuse the lack of parameter explanation.

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 only parameter 'limit_chars' has a default and type in the schema, but the description does not explain its purpose or usage. Schema description coverage is 0%, so the description should compensate but fails to do so.

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 reads the OctaneX MCP recipe book, specifying the action and resource. However, it does not explicitly distinguish from sibling tools like octane_load_recipe or octane_recipe_index, which also involve recipes.

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 octane_load_recipe or octane_recipe_index. It only states what it does, not when it 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 must carry the full burden. It discloses that the tool lists recipes with metadata and status, but does not mention access requirements, potential side effects (likely none), or what 'checked-in' means. The description is adequate but lacks depth.

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 redundant words. It efficiently conveys the tool's purpose and output.

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 a likely output schema (not shown but present), the description is fairly complete. It explains what is listed and what information is returned. However, it could mention if results are paginated or ordered.

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?

There are no parameters, so schema coverage is 100% by default. The description adds meaning by specifying what the output includes (metadata, verification status), which compensates for the lack of parameter details. Baseline for 0 parameters is 4.

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 'List', the resource 'checked-in example recipes', and the included information 'normalized metadata and preview/native verification status'. It distinguishes itself from sibling tools like octane_load_recipe or octane_build_scene by focusing on listing existing recipes.

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 vs alternatives like octane_recipe_book or octane_queue_recipe. The context from sibling names implies it is for browsing available recipes before loading or queuing, but the description does not state this or provide any exclusions.

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

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

Without annotations, the description carries the full burden. It states the action (append) and target, indicating a write operation. However, it lacks details on file handling (e.g., if file is missing, append behavior on multiple calls) or any 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 very concise (12 words) but at the expense of essential information about parameters and usage. It does not earn its place because it fails to add value beyond a minimal statement of purpose.

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

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

Given the tool has 6 parameters (including arrays and nullable values) and no schema descriptions, the description is severely incomplete. It does not explain the output schema, parameter meanings, or any behavioral nuances, leaving the agent with insufficient 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?

The description does not refer to any of the 6 input parameters (title, outcome, context, steps, signals, follow_ups). With 0% schema description coverage, the agent has no clue how to populate these fields, making the tool nearly unusable without additional knowledge.

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 appends a compact success/failure note to a specific file (docs/recipe-book.md) for future agents. This distinguishes it from siblings like octane_load_recipe or octane_queue_recipe which deal with executing or reading recipes.

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 prerequisites, exclusions, or context for choosing this over other recipe-related tools.

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

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

With no annotations, the description must disclose behavioral traits but only states 'remove' and 'resave'. No mention of side effects, reversibility, permissions, or what happens to dependent objects. The destructive nature is implied but not explicitly detailed.

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, front-loading the core action. It wastes no words but could benefit from additional detail without becoming verbose.

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

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

Given the tool has two required parameters and no annotations, the description is too minimal. It omits return value information, error conditions, and behavioral context about what 'remove' entails (e.g., whether it's permanent). The presence of an output schema is noted but not used in the description.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameters (scene_id, object_id). It does not explain what these identifiers represent or how to obtain them.

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

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

The description clearly states the action (remove), the resource (object from saved scene manifest), and the side effect (resave). It distinguishes from sibling tools like octane_add_object and octane_update_object.

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., octane_update_object). No mention of prerequisites, limitations, or 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; description only says load and queue without disclosing side effects (e.g., idempotency, overwrite behavior, prerequisites). Minimal disclosure.

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

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

One sentence, no wasted words. Could benefit from a slightly more structured breakdown but remains 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?

Output schema exists but description omits failure modes, prerequisites, or distinction from similar tools (e.g., octane_load_scene_manifest). Incomplete for a mid-complexity 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?

Single parameter scene_id has no schema description (0% coverage). Description mentions 'saved scene manifest' but doesn't clarify format or valid values, leaving the agent guessing.

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

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

Clearly states the tool loads a saved scene manifest and queues its validated commands. Differentiates from siblings like octane_load_scene_manifest (load only) and octane_queue_recipe (recipe vs scene).

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?

Implies usage for requeuing validated commands from a saved manifest but lacks explicit when-to-use, when-not-to-use, or alternatives.

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 full burden for behavioral disclosure. It mentions the tool reviews images but does not state whether it is read-only, if it has side effects, authentication requirements, or what happens to the data. The behavioral scope is too narrow.

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 front-loaded with the core action. However, it sacrifices parameter information and context for brevity. It is not verbose but could include more key details without becoming excessively long.

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 one unexplained parameter, no annotations, and only a brief description, the description is insufficient for full understanding. While an output schema exists (reducing need to explain return values), the lack of parameter documentation and behavioral context makes it incomplete for effective use.

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 one parameter 'path' with 0% description coverage. The description fails to explain what 'path' represents (e.g., file path or identifier) or how to use it. The purpose of the parameter is completely absent from the description.

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

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

The description clearly specifies the tool's action (review), resource (saved PNG preview), and criteria (blank/clipped/low-contrast) using image-level QA metrics. It distinguishes itself from siblings like octane_save_preview which saves, not reviews.

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 context (reviewing saved previews) but provides no guidance on when to use this tool over alternatives like octane_visualize_* tools or when not to use it. No exclusions or prerequisites are stated.

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

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

No annotations provided. The description does not disclose behavioral traits such as whether the operation is destructive, requires certain permissions, or is blocking. The parameters (dry_run, timeout_seconds) hint at behavior but are not explained.

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, but its brevity sacrifices necessary detail. It is front-loaded but lacks structure or elaboration.

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 (3 parameters with no documentation, no annotations, and an output schema), the description is incomplete. It does not explain return values, error conditions, or side effects.

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%. The description adds no meaning to the three parameters (mode, dry_run, timeout_seconds), leaving the agent to guess their purpose and valid values.

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

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

The description clearly states the tool runs a generated Octane bridge script from the Scripts menu via AppleScript, specifying the verb and resource. However, it does not differentiate from similar tools like octane_run_oneshot_bridge or octane_start_persistent_bridge, leaving some ambiguity.

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

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

No guidance on when to use this tool versus alternatives. It does not mention prerequisites, when to avoid, or context for use.

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

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

No annotations are provided, so the description carries the full burden. It mentions running a Lua script via AppleScript and draining a queue, but does not disclose potential side effects (e.g., destructive nature), authentication needs, rate limits, or what happens to the queue items. The agent lacks critical behavioral details.

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

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

The description is a single concise sentence that front-loads the main action and purpose. It avoids verbosity, but could provide more information without becoming overly long. Every word earns its place, but it lacks parameter and behavioral details.

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

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

Given the tool's complexity (draining batch queues via AppleScript/Lua) and the presence of a non-trivial output schema, the description is insufficient. It does not explain prerequisites, output behavior, or potential impact on the system. Agent needs more to use effectively.

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%, meaning the parameters lack descriptions in the schema. The tool description does not mention the two parameters ('dry_run' and 'timeout_seconds') at all, providing no guidance on their meaning or usage. This is a significant 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 clearly states the action ('Run'), the specific resource ('hermes_bridge_oneshot.generated.lua'), the method ('via AppleScript'), and the purpose ('for batch queue draining'). It effectively distinguishes from the sibling 'octane_run_bridge' by specifying it's a oneshot operation.

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

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

The description implies the tool's usage scenario: 'for batch queue draining'. This provides clear context for when to use it, though it does not explicitly exclude alternatives or mention when not to use. The sibling 'octane_run_bridge' exists, but the description gives enough implication.

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

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

With no annotations, the description carries the full burden. It explains convergence behavior (ceiling based on quality tier), the interplay between maxRenderTime and timeout_seconds, best-effort saving on timeout, and progressive output. However, it does not disclose whether the save actually writes a file to disk, what happens to existing files, or what the function returns beyond queuing a command.

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, using three short paragraphs. The first sentence immediately states the main action. The following paragraphs add detail but avoid unnecessary fluff. Minor improvement could be more structured bullet points or clearer separation of parameter explanations.

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 9 parameters, no annotations, and an output schema, the description provides moderate context. It explains the core rendering behavior and key parameters but omits the path/width/height semantics and the nature of the 'queue' (synchronous? asynchronous?). The output schema exists but the description doesn't summarize what it returns. More detail would make it fully actionable.

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%, so the description must compensate. It explains quality presets (standard=30s, etc.) and mentions overrides for samples, min_samples, timeout_seconds, and max_render_time. It also explains progressive. However, it does not describe the path, width, or height parameters, leaving their meaning and defaults (if any) unclear. Thus, while helpful, it is incomplete for all 9 parameters.

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: 'Queue a render-ready preview image save command.' It uses a specific verb ('queue' and 'save') and resource ('preview image'), distinguishing it from sibling tools like octane_review_preview (which likely reviews rather than saves) and octane_start_render (which starts a render but doesn't necessarily save a preview).

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 guidance on when to use the quality parameter with convergence presets and the progressive parameter for an early low-spp frame. It explains overrides for samples, min_samples, timeout_seconds, and max_render_time. However, it does not explicitly state when to use this tool versus alternatives like octane_start_render or octane_review_preview, leaving some ambiguity.

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

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

With no annotations, the description carries the full burden. It discloses that the tool validates and saves a manifest and does not queue commands, but it lacks details on side effects, failure behavior, or return values. The primary behavior is clear but not comprehensive.

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

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

The description is a single sentence, concise and front-loaded. However, it could include more detail without becoming overly long. It earns points for brevity but loses some for omitting parameter 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?

Given the vague input schema, lack of parameter descriptions, and no annotations, the description is insufficient for an agent to reliably construct a correct 'scene_plan'. The output schema exists but is not described, and the tool's validation behavior is not elaborated. The description is too sparse for a tool with such open-ended input.

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 elaborate on the 'scene_plan' parameter beyond calling it a 'semantic scene plan manifest'. The schema is vague (object with additionalProperties), and the description adds minimal guidance on expected structure or constraints.

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

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

The description clearly states the action ('Validate and save') and the resource ('semantic scene plan manifest'). It differentiates from siblings that might queue commands by adding 'without queueing commands', though it could be more explicit about when to use this vs other save/load 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?

No explicit guidance on when to use this tool versus alternatives like octane_load_scene_manifest or octane_validate_command. The description implies a use case (validating and saving without queuing) but does not provide when-not or trade-offs with 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 disclose behavioral traits. It does not state whether the tool is read-only, has side effects, or requires any permissions. The tool likely just returns data, but the description fails to confirm this.

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

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

The description is a single sentence that conveys the essential information without any fluff. Every word earns its place, and the structure is optimally concise.

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 zero parameters and an output schema (indicated), the description adequately covers what the tool returns. It could be more detailed about what 'schema' and 'limits' entail, but it is sufficient for an agent to understand the tool's purpose.

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's job is to explain what the output contains. It lists 'command schema, operation list, limits, and examples', adding meaning beyond the empty input schema. Per the rules, a baseline of 4 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 clearly states the tool returns 'the supported command schema, operation list, limits, and examples'. This is a specific verb+resource combination that distinguishes it from sibling tools, all of which perform actions rather than returning metadata.

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. While it's reasonable to infer it's for discovering available commands and their structure, explicit usage context or when-not-to-use hints are missing.

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. Description uses 'queue', suggesting asynchronicity, but doesn't explain behavioral traits like whether it's destructive, requires permissions, or has 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?

Extremely short (5 words) but fails to convey necessary information. It's under-specified, not concise.

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

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

With 3 undocumented parameters, no annotations, and an output schema not described, the description is far from complete. It lacks essential details for tool invocation.

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

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

Schema coverage is 0% and description provides zero parameter information. Parameters 'position', 'target', and 'fov' are undefined, leaving agent clueless about their 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?

Description 'Queue a camera placement command' indicates a camera-related action but is vague. It doesn't clearly distinguish from sibling tools like 'octane_suggest_camera_fix' or imply what 'placement' entails.

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 vs alternatives. Agent receives no context about prerequisites or scenarios for camera placement.

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. Saying 'queue' hints at deferred execution but gives no details on whether it is asynchronous, destructive, or what side effects occur. No mention of permissions or scene state impact.

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 too short (5 words) and fails to convey essential information. It is under-specified rather than concise, lacking structure or key details.

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

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

Given the tool has one parameter and an output schema, the description should explain what queuing means, the effect on the scene, and the nature of the output. It is incomplete and leaves critical gaps for an AI agent.

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

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

The schema has 0% description coverage and the parameter name 'preset' is self-explanatory. The description does not list possible values, explain the default 'soft_studio', or provide any syntax guidance. It adds no meaning beyond the schema.

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

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

The description identifies the verb 'queue' and resource 'lighting preset command', but 'command' is vague and does not clarify what queuing entails (e.g., immediate vs. deferred). It is somewhat distinct from siblings like octane_create_light, but the differentiation is implicit.

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 like octane_create_light or octane_suggest_lighting_fix. No usage context or prerequisites are mentioned.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states 'Show' but does not detail side effects, prerequisites, or whether this modifies the scene. The agent is left uncertain about what exactly happens.

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

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

The description is a single, efficient sentence that immediately conveys the tool's purpose with no unnecessary words.

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 an output schema, the description is adequate but lacks behavioral context and parameter explanation, which are needed given the number of sibling 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?

The input schema has 0% description coverage for the single parameter 'name', and the tool description does not explain its purpose or acceptable values beyond the default 'hermes_avatar_face'.

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 'Show Hermes' geometric avatar face as a scene guide in Octane' uses a clear verb (Show) and specific resource (Hermes' geometric avatar face), distinguishing it from sibling tools like octane_add_object or octane_set_camera.

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 when-to-use or when-not-to-use guidance is provided. The description implies utility as a scene guide, but does not contrast with alternatives like octane_add_object for adding other objects.

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 says 'open/manage the persistent bridge.' It does not explain what 'persistent' means, whether it blocks, requires a running Octane, or what side effects occur. The parameters dry_run and timeout_seconds are not explained.

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

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

The description is a single sentence, which is concise, but it lacks structure and does not earn its place due to missing critical information. It is not overly verbose but is incomplete.

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 an output schema and two parameters with no annotations, the description is insufficient. It does not explain what the output represents or how the parameters affect behavior. The agent would struggle to invoke this tool correctly without additional knowledge.

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

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

The schema has 0% description coverage, so the description must compensate. However, it provides no information about the meaning or effect of the two parameters (dry_run, timeout_seconds). The agent cannot infer how to use them correctly.

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 it runs a specific Lua script via AppleScript to open/manage a persistent bridge, which gives a basic idea. However, it does not differentiate from similar sibling tools like octane_run_bridge and octane_run_oneshot_bridge, leaving ambiguity about when to use this specific tool.

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

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

No guidance is provided on when to use this tool versus the alternatives. There is no mention of prerequisites, context, or situations that warrant a persistent bridge over a oneshot.

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 convey behavioral traits. It only says 'queue a command,' but does not disclose side effects, asynchronous behavior, or error conditions. The agent has no idea what happens after queuing.

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

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

The description is a single sentence, but it is underspecified. Conciseness should not sacrifice essential information; here critical details are missing, making it inadequate rather than concise.

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 3 parameters, no annotations, and an output schema, the description fails to explain the rendering process, how parameters affect the output, or what the tool returns. It is not complete enough for an agent to use correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does not mention width, height, or samples at all, leaving their meaning and impact entirely unclear.

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 'Queue a render start/restart command' clearly states the verb (queue) and resource (render start/restart). The purpose is understandable, but it does not differentiate from sibling tools that may also queue operations (e.g., octane_queue_recipe).

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. The description lacks context about prerequisites, expected state, or scenarios where 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 must carry the burden of behavioral disclosure. While 'Return' implies a read-only operation, the description does not explicitly state that the tool is non-destructive, safe, or has no side effects. The simplicity of a status-check tool partially compensates, but more transparency would be beneficial.

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

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

The description is a single, clear sentence. It is extremely concise with no redundant words or repetition. 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 the tool has no parameters and has an output schema, the description is fully adequate. It states exactly what data the tool returns, and the output schema handles the return structure details. The context is complete for a simple status query 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 description coverage is trivially 100%. According to the rubric, baseline for 0 params is 4. The description does not need to add parameter information, and it correctly explains the output scope.

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

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

The description uses a specific verb 'Return' and clearly lists three distinct resources: Octane X app, bridge heartbeat, and command queue status. This clearly defines what the tool does and distinguishes it from sibling tools like octane_bridge_process_status or octane_ping.

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. Among siblings, there are related tools (e.g., octane_bridge_process_status), but no indication of when to prefer this one. No exclusions or context are given.

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

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

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as whether the tool is read-only, destructive, or requires certain permissions. The verb 'suggest' implies no modification, but this is not explicit.

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

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

The description is a single short sentence, which is concise but severely under-specified. It lacks critical context that would make it useful for an AI agent to decide when and how to use the 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 complexity (nested objects, no annotations, no param descriptions), the description is far from complete. It does not explain return values, prerequisites, or the nature of a 'camera patch'. Even with an output schema, the description fails to provide sufficient 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 does not explain the structure or expected fields of the two object parameters (preview_review, asset_bounds). The description only names them without adding meaningful detail beyond the parameter names.

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

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

The description uses a specific verb 'Suggest' and resource 'camera patch', and mentions inputs 'preview QA output and asset bounds'. It differentiates from sibling tools like octane_set_camera (direct setting) and octane_suggest_lighting_fix (lighting fix). However, the exact meaning of 'camera patch' is not elaborated, so it's not perfectly clear.

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

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

No guidance on when to use this tool vs. alternatives. It does not mention prerequisites, context, or when not to use it. The description only states what it does, not when it should be chosen over other 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 disclose behavioral traits. It does not state whether the tool is read-only, modifies state, requires permissions, or has side effects. The description is insufficient for an agent to understand the tool's impact.

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 single sentence is concise, but it lacks essential information about parameters and behavior. Conciseness is about efficient communication, and here it under-informs, so it scores average.

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 schema description, no annotations, and a complex nested input parameter, the description is severely incomplete. The output schema exists but is not referenced, and the agent cannot properly invoke the tool without more details.

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

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

Schema description coverage is 0%, and the description does not mention the 'preview_review' parameter at all. The agent gets no additional meaning beyond the schema schema, which is minimal for a nested object type.

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 'suggest' and the resource 'lighting/render patch', with source 'preview QA output'. It distinguishes from sibling tools like octane_set_lighting by indicating it uses QA output to suggest fixes, though 'patch' is somewhat vague.

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

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

No guidance on when to use this tool versus alternatives like octane_set_lighting or octane_create_light. It implies use after preview QA but doesn't state when not to use it or provide any contextual 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?

With no annotations, the description carries the full burden. It only states 'update' and 'resave', which implies mutation, but does not discuss permissions, side effects, or allowed changes beyond a basic update.

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 single sentence is concise and front-loaded, but it sacrifices necessary detail. It is not verbose, but could include more without losing conciseness.

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 (3 params, 0% schema coverage, no annotations, mutation behavior), the description is inadequate. It fails to explain what changes are valid, what the output is, or any 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 description coverage is 0%. The description does not explain any of the three parameters: scene_id, object_id, or changes. The 'changes' object is left undefined, which is critical for correct invocation.

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 updates an object in a scene manifest and resaves it. The verb 'update' and resource 'object' are specific, and it implicitly distinguishes from add/remove siblings, though not explicitly.

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

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

No guidance is provided on when to use this tool versus alternatives like octane_add_object or octane_remove_object. The description lacks context for usage.

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 fully disclose behavioral traits. It does not state whether the tool is read-only, has side effects, or what happens on success/failure. Merely says 'validate', which is vague.

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

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

Single sentence, front-loaded, no redundancy. Efficient, though could be more informative without adding length.

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

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

The tool has an output schema (unseen) but the description does not mention return values or behavior. Given one parameter and no annotations, the description should at least hint at validation outcomes. Many sibling tools exist but no differentiation provided.

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

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

With 0% schema description coverage, the description should compensate. It adds the term 'command envelope' to the 'command' parameter, but provides no details about expected structure, constraints, or validation criteria.

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

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

The description clearly states the action (validate) and the object (one JSON command envelope), distinguishing it from sibling validation tools like octane_validate_queue and octane_validate_recipe_library. However, it lacks specificity about what 'validation' entails.

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

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

The description implies use 'before it is queued or replayed' but does not explicitly state when to use this tool over alternatives. No guidance on prerequisites or when not to use.

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

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

No annotations are provided, so the description must disclose all behavioral traits. It only states the action, but does not mention whether validation is read-only, if files are modified, or what the output contains. This is insufficient for safe agent 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?

The description is a single sentence with no unnecessary 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 an output schema exists, the description is mostly complete. However, it could be improved by briefly explaining what validation entails (e.g., syntax checking) to set expectations.

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?

There are no parameters, so schema coverage is 100%. The description adds meaning by specifying the scope ('all queued command JSON files') and context ('current workspace'), which goes beyond the empty schema.

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

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

The description clearly states the action ('validate') and the resource ('all queued command JSON files in the current workspace'). It is specific and distinct from sibling tools like 'octane_validate_command' which validates a single command.

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 there are queued commands to validate, but it does not explicitly state when not to use it or mention alternatives. Sibling tools exist (e.g., 'octane_validate_command') but no 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?

No annotations are provided, so the description carries full burden. While it states what is validated, it does not disclose behavioral traits such as whether validation is read-only, what happens on failure, or any required permissions. This is a significant gap for a validation tool.

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

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

The description is a single, concise sentence that begins with the verb 'Validate'. It contains no redundant information and efficiently communicates the tool's purpose.

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

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

Given the tool has no parameters and an output schema exists, the description does not need to explain return values. It adequately covers what the tool validates. However, more context on the 'recipe library' concept could help differentiate from many sibling 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?

The tool has zero parameters, so the schema already fully documents the input. The description adds meaning by specifying the validation scope (metadata, files, previews, command payloads), which compensates for the lack of parameter details.

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

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

The description clearly states the verb 'Validate' and the resource 'checked-in recipe metadata, required files, previews, and command payloads'. It distinguishes from sibling tools like octane_validate_command and octane_validate_queue by specifying the scope as the recipe library.

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 validating recipe library artifacts but does not provide explicit guidance on when to use it versus alternatives like octane_validate_command. No exclusions or contexts are mentioned.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the basic function. It does not explain how the chart is presented (e.g., displayed in a viewport or returned as data), any side effects (e.g., creating a scene object), or error conditions. This lack of transparency hinders correct 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?

The description is a single sentence, which is concise but too brief. While it states the core purpose, it omits important details, making it minimally adequate. It could be restructured to include essential information without significant added length.

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 an output schema and sibling visualization tools, the description is incomplete. It does not explain the output format, the role of the 'name' parameter, or how to choose between this and similar tools. The presence of an output schema does not absolve the need for high-level behavioral 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 information about parameters. The 'name' parameter with default 'visual_bar_chart' is unexplained, leaving its purpose ambiguous. The description fails to compensate for the missing schema descriptions.

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

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

The description clearly states the tool visualizes numeric values as a 3D bar chart, specifying the action and resource. Among siblings like octane_visualize_scatter and octane_visualize_surface, the bar chart type is distinctive, but the description does not explicitly differentiate or add context.

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

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

The description provides no guidance on when to use this tool versus alternatives like scatter or surface plots. It does not mention data suitability, prerequisites, or when not to use, leaving the agent to infer usage from the name alone.

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?

Without annotations, the description discloses key behaviors: accepted GeoJSON formats, extrusion behavior, requirement of shapely, and graceful failure with install hint. It does not cover edge cases like invalid GeoJSON or performance, but provides substantial 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 concise, with two paragraphs: first explaining functionality, second detailing return value. It is front-loaded and clear, though could omit 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 4 parameters and no annotations, the description covers input format, output (asset path, commands, bridge status), and a key prerequisite. However, missing descriptions for 'color' and 'z_extrude' parameters leave gaps for full 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 input schema has 0% description coverage, and the description only explains the 'geojson' parameter indirectly. Parameters like 'name', 'color', and 'z_extrude' (default 0.5) are not described at all, leaving their purpose unclear.

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 visualizes GeoJSON or shapely geometry as extruded geometry in Octane, with specific mapping rules (points to marker boxes, lines/polygons to extruded walls). It distinguishes from siblings like octane_visualize_bars by focusing on GeoJSON input.

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 GeoJSON or shapely geometry needs 3D visualization, and notes the prerequisite of the 'geo' extra. However, it does not explicitly state when not to use this tool or mention alternatives among 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 provided, and the description does not disclose any behavioral traits (e.g., readOnly, destructive, side effects). Fails to compensate for missing annotations.

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?

Description is very short, but includes unnecessary parenthetical '(WP6)' that confuses. Could be clearer while remaining concise.

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 visualizing network topology and the presence of an output schema, the description is incomplete. Does not explain output, usage of overrides, or required setup.

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 one parameter 'overrides' with no description, and schema description coverage is 0%. The tool description does not explain its purpose or values.

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

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

Description mentions 'queue the knowledge graph / network topology recipe' but doesn't clearly state what the tool does or what 'queue' means. The purpose is vague compared to siblings like 'octane_visualize_bars'.

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 the many other visualization siblings. Does not mention prerequisites or suitable contexts.

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

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

No annotations are provided, and the description only says 'Visualize', which is ambiguous about side effects (e.g., does it render an image or modify state?). It does not disclose behavioral traits like whether it is read-only or returns output.

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

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

The description is a single, clear sentence with no wasted words. It is front-loaded and appropriately concise.

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 basic purpose and hints at the format of 'points' via 'xyz', but lacks details on parameter constraints and return value. Given the presence of an output schema, the description is minimally adequate but has clear 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?

Schema description coverage is 0%, and the description does not explain the two parameters ('name' and 'points'). It adds no meaning beyond the schema, failing to compensate for the low coverage.

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

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

The description clearly states the verb 'Visualize' and the resource 'xyz points as a 3D scatter plot in Octane'. It distinguishes this tool from siblings like 'octane_visualize_bars' and 'octane_visualize_network' by specifying 'scatter' and '3D'.

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 prerequisites, typical contexts, or exclude scenarios.

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

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

With no annotations provided, the description carries the full burden. It mentions that expressions can use x, y, r and safe math functions, which is useful. However, it does not disclose error handling, performance implications of high steps, or whether the tool generates a preview or returns data. An output schema exists but is not referenced.

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

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

The description is a single sentence, very concise and front-loaded with the core purpose. However, it could benefit from a brief structured list or example to aid readability without adding much length.

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 7 parameters and is used for 3D surface visualization, the description is too sparse. It lacks details on how parameters interact, expected output format (though output schema exists), and use cases. The description feels incomplete for an agent to use effectively.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains that the expression parameter supports x, y, r and safe math functions. The six other parameters (name, steps, x_min, x_max, y_min, y_max) are not described, leaving their meaning to be derived from defaults and titles alone.

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

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

The description clearly states the tool visualizes z=f(x,y) as a 3D surface, which is a specific verb-resource combination. It distinguishes from sibling visualization tools that handle bars, geojson, network, and scatter plots.

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 plotting a mathematical surface function, but does not explicitly state when to use this tool over alternatives or when not to use it. No exclusion criteria or comparative guidance is provided.

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