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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing about the mutation actions. 'Register' and 'upload' imply writes but there is no statement about permissions, reversibility, side effects, or what 'through the configured backend' actually changes. Only the mention of a 'configured backend' adds minor context.

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

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

A single, front-loaded sentence that enumerates the four actions efficiently with no filler. The only cost is slightly opaque jargon ('tagged provider reference'), but structurally it is tight and readable.

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

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

With no annotations, no output schema, 0% parameter documentation, and a 7-parameter multi-action surface, the description is materially incomplete. An agent cannot determine per-action parameter requirements, side effects, or prerequisites from what is written.

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?

Seven parameters with 0% schema description coverage leaves the description fully responsible, and it documents none of them directly. Only weak hints exist ('project-owned' ~ project_id, 'tagged provider reference' ~ roles, 'configured backend' ~ backend_profile_id), while asset_id, relative_path, and work_item_id are entirely unexplained. This fails to compensate for the coverage gap.

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

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

The description uses clear verbs and maps closely to the four enum values of the action parameter: 'Inspect' (inspect), 'register' (register), 'prepare' (prepare), and 'upload' (upload). The resource is stated ('project-owned assets'). However, it does not differentiate this tool from siblings like rh_upload_lora or rh_project, and 'prepare a tagged provider reference' is jargon that only loosely anchors the 'prepare' action.

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

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

There is no explicit when-to-use guidance, no conditions that select among the four actions, and no routing to alternatives such as rh_upload_lora. The 'explicitly upload' phrasing hints at an implicit alternate upload path but never names or explains it. Usage must be inferred entirely from the action names.

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

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

No annotations are provided, so the description must carry the full behavioral load. It discloses the crucial negative trait (does not submit a task), which is useful. But it omits whether the example is returned inline, how errors are surfaced, or the difference between modes. That is thin for a no-annotation 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?

Single tight sentence, front-loading the affirmative action and ending with the critical non-submission constraint. No filler, though it is arguably too terse given the surrounding gaps.

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 2-parameter surface, the lack of annotations, and the dense sibling set, the description is not complete enough: no explanation of endpoint format, mode semantics, or return behavior. The one genuinely useful disclosure (non-submission) isn't enough to compensate.

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%, yet the description mentions neither 'endpoint' nor the 'mode' enum values ('minimal', 'with_optional_defaults'). Since the schema provides no descriptions, the description fails to compensate by explaining what endpoint expects or what the modes produce.

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

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

States a clear verb+resource: build an example payload from a public model schema. However, the description doesn't distinguish from adjacent siblings like rh_validate_payload or rh_get_model_schema, which involve similar payload/schema handling. An agent might confuse it with tools that also produce or act on a payload.

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 only usage signal is the exclusionary clause 'it does not submit a task.' No explicit when-to-use or when-to-prefer-alternatives is given despite many sibling tools in the same domain (rh_validate_payload, rh_run_workflow, rh_prepare_generation).

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 and does disclose two important traits: the revision is immutable and no cloud task is submitted (side-effect scope). It omits permissions/auth, conflict or duplicate-workflow behavior, and error conditions, leaving meaningful gaps for a create operation.

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

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

Two tight sentences, front-loaded with the core action and followed by the key constraint. No filler.

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

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

No output schema and no annotations, so the description must carry everything, yet it says nothing about the five parameters, the return value (e.g., new revision identifier), or failure modes. The local/immutable framing is useful but insufficient for a 5-param create 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 schema has 5 parameters at 0% description coverage, so the description must compensate. It only hints at api_graph via 'API graph' and its optionality via 'or an empty draft'; project_id, workflow_id, reason, and output_nodes are entirely unexplained in both places.

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

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

States a specific verb+resource ('Create an immutable local workflow revision') and clarifies the two input modes (API graph or empty draft), which separates it from rh_edit_workflow and rh_import_workflow. It does not name a sibling explicitly, so it stops short of a 5.

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

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

'No cloud task is submitted' implies usage boundaries by contrast with rh_run_workflow, but the agent must infer that this is the local-only authoring step. There is no explicit when-to-use, when-not-to-use, or named alternative.

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

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

With no annotations, the description must carry the full behavioral burden, and it does disclose two important traits: batch atomicity and all-or-nothing failure semantics ('failed batches create no revision'), plus the CAS precondition implied by 'compare-and-swap'. However, it omits what happens on a revision conflict, permission requirements, and the meaning of the required 'reason' field.

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

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

A single front-loaded sentence that conveys the action, the atomicity guarantee, and the failure behavior with zero filler. Nothing redundant and nothing buried.

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 high-complexity mutation tool with ten operation variants, no annotations, no output schema, and 0% schema coverage, the description is far too thin. It never explains the CAS precondition that base_revision_id encodes, the role of 'reason', or the semantics of the operation batch it accepts.

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% across 4 required parameters and a deeply nested union of ten operation types, so the description is the only source of meaning. It obliquely signals that base_revision_id drives compare-and-swap, but adds nothing about workflow_id, reason, or the operations structure, leaving most parameters undocumented in both schema and description.

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

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

States a specific verb+resource pair ('Apply an atomic typed graph edit batch') and names the concurrency mechanism ('compare-and-swap'), so an agent can tell this mutates a workflow graph rather than reading, validating, or creating one. It stops short of explicitly distinguishing itself from close siblings like rh_create_workflow or rh_validate_workflow.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance is given. An agent gets no signal on whether to call rh_validate_workflow or rh_get_workflow first, or when to prefer this over rh_create_workflow. Only the failure trait ('failed batches create no revision') hints at context.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one useful trait — the result is an estimate, not official pricing — but says nothing about auth requirements, rate limits, what the nested payload must contain, or what the response returns.

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

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

Two short, front-loaded sentences with no filler; the core action leads. The brevity comes at the cost of substance, but structurally it is 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?

For a tool with an undocumented nested payload object and no output schema, the definition is too thin — it omits what to pass for 'endpoint' and 'payload' and what the estimate result looks like, so an agent cannot call it correctly from the description alone.

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 two parameters, one of which is a free-form nested object with additionalProperties. The description adds no meaning about 'endpoint' or 'payload' structure, leaving both entirely opaque to the 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 states a specific verb (Estimate) and resource (a public catalog price), which distinguishes it from the workflow/model siblings. It is clear what the tool does at a high level, though it never explains what the cryptic 'endpoint' identifier refers to.

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?

'Verify official RunningHub pricing before showing a final cost' implies a usage context (pre-flight cost estimation, not authoritative), which is helpful. However, it names no alternatives and gives no explicit when-to-use/when-not conditions relative to the many 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?

With no annotations, the description carries the full behavioral burden. It does add real value by disclosing that the export is local (no network/cloud submission) and that secrets are stripped, which implies a safe read. It stops short of stating read-only semantics explicitly, error behavior, or what the exported payload surface looks like.

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

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

A single front-loaded sentence with no filler; every clause (local, revision, API JSON, no secrets, no cloud) carries 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 no output schema and no annotations, the definition is only partially complete: it never says whether output is returned inline or written to a file, nor how it behaves for non-local/cloud workflows. The omitted revision_id/when-to-use guidance leaves real gaps for a 3-parameter tool.

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

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

Schema description coverage is 0% for three parameters, so the description must compensate but adds almost nothing: it never explains the workflow_id vs revision_id distinction or whether revision_id is optional (defaulting to latest). Only 'format' is self-documenting via its const/enum.

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

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

States a specific verb (Export) and resource (local workflow revision) and pins the output format (API-format JSON). The qualifiers 'local' and 'without cloud submission' cleanly separate it from the inverse sibling rh_import_workflow and from cloud-side reads like rh_get_workflow.

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 statement of when to choose this over rh_get_workflow, rh_import_workflow, or rh_validate_workflow, and no prerequisites or exclusions. The agent must infer the use case from the phrase 'local workflow revision' 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?

With no annotations, the description carries the full behavioral burden. It does disclose one meaningful trait — the response will not expose secrets — which signals a safe, read-oriented operation, but it says nothing about permissions, side effects, or output stability.

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

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

A single tight sentence with no filler, and the security constraint is placed at the end where it reads as a qualifier. Efficient, though the front-loaded content is a bit abstract rather than actionable.

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?

There is no output schema, no annotations, and two undocumented parameters, yet the description does not explain what 'capability evidence' is returned, nor how backend/profile shape the result. For an introspection tool with zero structured support, this leaves real 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%, so the description must compensate and does not. It never mentions the 'backend' parameter (with its workflow_api/comfy_proxy/standard_model enum) or the 'profile' parameter, leaving an agent unable to know what either filters or selects.

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

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

The description names a specific verb (report) and concrete resources (local server, catalog provenance, backend capability evidence), so an agent can tell this is a read-only capability/introspection tool. It does not, however, differentiate itself from siblings like rh_get_integration_guide or rh_get_model_schema, and 'capability evidence' is somewhat abstract phrasing.

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

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

There is no indication of when to call this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer that this is a discovery/introspection step 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?

No annotations, so the description carries the burden. 'Public-safe' hints at what is redacted/omitted, which is useful, but there is no disclosure of latency, caching, auth requirements, or what 'public-safe' excludes. Read-only nature is only implied by 'Return'.

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, front-loaded with the verb and resource, no filler. Appropriate length for a single-parameter lookup tool.

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

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

For a documentation-retrieval tool with no output schema and no annotations, the description should say what form the guidance takes, whether it is static or model-family-specific, and how the topic enum behaves. Several of these gaps remain.

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%, but the single parameter is a fully enumerated topic list, so the schema itself conveys the value space. The description adds nothing about the enum values or the default when topic is omitted (it is not required).

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

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

Clear verb ('Return') plus resource ('integration guidance') scoped to the 'optional standard model API family'. Distinguishable from siblings like rh_get_model_schema or rh_get_capabilities, though the 'optional standard model API family' phrasing is somewhat opaque without outside 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?

No statement of when to use this versus rh_get_model_schema, rh_get_capabilities, or rh_build_example_payload, which cover adjacent ground. The reader has to infer that this is the documentation-lookup tool for integration topics.

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 behavioral burden. It discloses that the tool returns a public schema and does not verify cloud access, but omits auth requirements, rate limits, and return behavior 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 front-loaded sentence with no wasted words. It is appropriately sized for the tool's simplicity.

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

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

For a simple one-parameter tool, the description conveys the core operation. However, with no output schema and no annotations, it lacks details about endpoint format and the returned schema structure.

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

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

Schema description coverage is 0%, so the description must compensate for the single endpoint parameter. It identifies the parameter as a catalog endpoint but gives no format, examples, or valid value guidance.

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

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

The description states a specific verb and resource: return a public schema for one catalog endpoint. It also adds a scoping caveat about cloud access, but it does not explicitly differentiate itself from siblings like rh_search_models or rh_get_capabilities.

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?

Usage is implied: use this to retrieve a public schema for a catalog endpoint. The negative constraint 'does not verify cloud access' is useful, but there is no explicit when-to-use, when-not-to-use, or named alternative.

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 and does disclose real side effects: it writes validated local original files, renders images inline in chat, and creates local derivative files without re-submitting a task. That is meaningful behavioral disclosure. It still omits permission/auth needs, overwrite behavior for existing files, and how unsupported formats are handled.

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

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

A single sentence, front-loaded with the primary action, with no filler. It is somewhat dense by packing three distinct behaviors into one clause chain, but every phrase adds information.

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

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

For a no-annotation, no-output-schema tool the description adequately conveys what happens on invocation. It leaves gaps on return shape, file naming/locations, and what 'confirmed' status entails, which an agent would need for reliable 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 description coverage is 0% and the description never mentions job_id or what a valid job id refers to. However, with only one self-evident required parameter, the gap is minor. Baseline is below 4 because the description adds no meaning over the schema for the lone parameter.

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

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

The description names concrete verbs and resources: downloading confirmed provider outputs, rendering supported images inline, and creating preview/poster derivatives. It is clearly distinct from a pure review tool, though it never explicitly names the sibling rh_review_result or rh_job it relates to. An agent can tell what the tool produces, but not precisely how it differs from the review/result siblings.

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

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

The phrase 'without submitting another task' implies this is a post-generation retrieval step that does not re-run anything, which is useful context. However, there is no explicit when-to-use statement, no prerequisites (e.g. job must be confirmed), and no naming of alternatives such as rh_review_result. Usage is only implied.

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 does disclose two useful traits — the revision is immutable (read-only assumption) and the response includes a validation report — but omits permission requirements, error behavior, and what happens for a missing revision. For a tool with zero annotation coverage this is thin.

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

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

A single front-loaded sentence with no waste. It is arguably too terse for the semantic burden it must carry, but there is no padding or redundancy.

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

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

With no annotations, no output schema, and 0% parameter description coverage, the description is the only source of semantics and leaves critical gaps: revision_id optionality/default, error cases, and how this differs from the many sibling workflow tools.

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

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

Schema description coverage is 0% for both workflow_id and revision_id, and the description explains neither. It never says that revision_id is optional (the schema marks only workflow_id required) or what the default revision is when omitted, which is the key caller decision here.

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

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

States a specific verb+resource ('Read a ... workflow revision') and adds a scoping qualifier ('local immutable') plus the return content ('validation report'). It does not differentiate itself from close siblings like rh_search_workflows or rh_validate_workflow, so it falls short of a 5.

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

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

There is no guidance on when to call this versus rh_search_workflows (to find a workflow), rh_validate_workflow (to validate one), or rh_export_workflow. The agent must infer usage purely from the tool name.

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

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

With no annotations, the description carries the full burden, but it does disclose one genuinely useful behavioral fact: 'no provider task is submitted,' which distinguishes it from execution tools like rh_run_workflow. It still omits whether import mutates project state, idempotency, overwrite behavior, and permission requirements.

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

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

A single tightly-packed sentence with the key constraint ('no provider task is submitted') front-loaded and no filler. It is efficient, though the compressed dual-mode phrasing slightly hurts readability.

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

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

For a 4-parameter tool with no annotations and no output schema, the description is thin. It leaves unclear what the tool returns (discovered paths? an import result?), what the optional parameters do, and how the two modes differ operationally.

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 4 parameters, so the description must compensate and largely does not. It gestures at a 'registered project' (project_id) and 'import one explicitly' (workflow_id), but says nothing about output_nodes or relative_path, leaving two parameters fully unexplained.

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

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

The description names a resource (API-format workflow JSON files) and two actions (discover or import), which is more than a tautology. However, the dual 'discover OR import' framing in a tool named 'import' is ambiguous about the primary purpose, and it does not distinguish itself from close siblings like rh_export_workflow, rh_create_workflow, or rh_get_workflow.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternative sibling is named. An agent cannot tell from this text whether to reach for this versus rh_export_workflow or rh_create_workflow, both of which are adjacent in the workflow lifecycle.

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 adds one specific behavioral trait: it will not hide provider errors and will not retry an uncertain submit. However, it omits other key behaviors such as permissions needed, side effects of cancel/resume, idempotency, or timeout semantics. The one disclosed behavior is useful but insufficient.

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 is front-loaded with purpose and then tacks on a behavioral caveat. It lacks structural separation between what the tool does and how it behaves, making it somewhat cryptic for a 4-action 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 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is far too thin. It states purpose and one behavior but leaves action semantics, parameter meanings, and return expectations unexplained. An agent would struggle to invoke this correctly without opening the schema.

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

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

Schema description coverage is 0% for 4 parameters, so the description must compensate. It provides no meaning for the action enum values, job_id, timeout_ms, or provider_task_id. The agent gains no semantic guidance beyond the raw schema constraints (enum, minLength, pattern).

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

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

The description states a clear verb-resource pair: 'inspect or advance one durable job.' This distinguishes it from most siblings (which handle workflows, models, assets), but it does not explicitly name or contrast with any specific sibling. The enum actions are not mentioned, though the overall purpose is clear.

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

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

There is no explicit when-to-use guidance, no when-not-to-use conditions, and no alternatives named. The phrase 'without hiding provider errors or retrying an uncertain submit' is a behavioral constraint, not usage guidance. An agent must infer when to call this tool versus others.

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

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

With no annotations, the description carries the full behavioral load. It usefully discloses immutability of the produced plan and the key side-effect boundary (no provider submission), which is real value. However, it omits prerequisites (e.g., whether the workflow must first be validated), error behavior, and idempotency.

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

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

A single, front-loaded sentence with zero filler. The main action and its key constraint are delivered immediately.

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

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

For an 8-parameter tool with nested objects, four required inputs, no annotations, and no output schema, one sentence is insufficient. The agent gets the core intent but none of the parameter-level or prerequisite context needed to invoke it correctly.

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

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

Schema description coverage is 0% across 8 parameters including nested objects, so the description must compensate. It only gestures at work_item_id and workflow_revision_id, leaving backend_profile_id, output_contract, mode, asset_bindings, provider_submit_mode, and provider_workflow_id unexplained in both schema and description.

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

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

States a specific verb ('Create') and resource ('immutable local execution plan') with clear inputs (one work item, one workflow revision). The clause 'no provider task is submitted' functionally distinguishes it from a run/submit sibling, though it does not name that sibling explicitly.

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

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

The 'no provider task is submitted' clause implies this is a pre-execution/dry-planning step, so usage is inferable, but there is no explicit when-to-use statement, no prerequisites, and no named alternative such as rh_run_workflow.

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 behavioral burden. It states the tool will not change files outside explicit roots, which is a useful constraint, but it does not disclose which actions mutate state, required permissions, or other side effects.

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

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

The description is a single front-loaded sentence that lists the operations and the scoping constraint with no filler. It is concise to the point of under-specification, but the dimension rewards brevity and 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?

With 8 parameters, four distinct actions, no annotations, and no output schema, the description is far too thin. It omits action-specific behavior, parameter roles, and safety details, leaving the agent unable to invoke the tool correctly without guesswork.

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% across 8 parameters, so the description must compensate but does not. It only vaguely alludes to 'explicit roots' without explaining action, project_id, asset_roots, output_root, canonical_root, document_paths, policy_revision, or backend_profile_id.

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

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

The description names four specific operations (register, inspect, list, index) on a project resource, so the agent can tell what the tool does at a high level. However, it does not distinguish itself from sibling tools like rh_asset or rh_scene, and the multi-action scope is clarified only by the action enum in the schema.

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

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

There is no guidance on when to choose register versus list versus inspect versus index, nor when to use this tool over sibling tools. The safety clause about explicit roots is a boundary statement, not usage 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 must carry the behavioral burden. It usefully states idempotency and conditional continuation side effects, but omits permissions, error behavior, effects of non-approved decisions, revision_request semantics, and validation constraints.

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 compact and front-loads the core purpose before the continuation note. It is concise, but its extreme terseness for a complex nested schema leaves critical structure unaddressed.

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

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

Given seven parameters, nested revision_request operations, no annotations, no output schema, and zero schema description coverage, the description is far too incomplete. It gives the basic action but leaves an agent without enough context to invoke the tool correctly across its full parameter surface.

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 seven parameters with 0% schema description coverage, and the description explains none of them in detail. It vaguely references an 'approved continuation' and 'next plan' but does not clarify decision values, result_id, feedback, revision_request, review_event_id, or user_message_ref.

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

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

The description states a specific verb and resource: 'Record one idempotent user review for a saved result.' It gives scope enough to understand the core operation, though it does not explicitly differentiate itself from other review-adjacent siblings.

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

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

It implies the tool is used for a saved result and notes that an explicitly approved continuation may run a prepared next plan. However, it provides no explicit when-not guidance or alternatives, leaving usage largely inferable.

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, and it does disclose one genuinely valuable behavior: repeated request IDs will not create a second local submit (idempotency). However, it says nothing about whether execution is asynchronous, what permissions are required, what happens to the durable backend state on failure, or what the caller receives back.

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

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

A single tightly written sentence with the core action front-loaded and the idempotency qualifier appended; there is no filler. It is perhaps slightly dense given the jargon, but every clause carries information.

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

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

For a submit-and-execute tool with no annotations, no output schema, and 0% parameter documentation, the description is too thin: it omits the required prerequisite (where plan_id comes from), the asynchronous or synchronous nature of the run, and any indication of the returned handle an agent would need to poll or retrieve results.

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

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

Schema description coverage is 0%, so the description must compensate for two undocumented required parameters. It partially does so: 'request ID' implies request_id is an idempotency key, and 'prepared execution plan' ties plan_id to a previously prepared plan, but neither parameter's format, provenance, or constraints are stated.

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

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

The description names a specific action (submit) on a specific resource (one prepared execution plan) via a durable backend, which is enough to separate it from siblings like rh_create_workflow or rh_validate_workflow. It does not explicitly call out those siblings, and 'prepared execution plan' is somewhat jargony, but the verb+resource pairing is unambiguous.

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

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

There is no explicit when-to-use guidance or comparison against alternatives such as rh_prepare_generation, rh_validate_workflow, or rh_get_results. The word 'prepared' hints that a plan must exist first, but the agent is left to infer the prerequisite and the ordering of steps from sibling names 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?

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing: 'upsert' is a mutation but no permissions, side effects, reversibility, or write semantics are disclosed. The distinction between 'read' and 'resolve' (the most important behavioral question here) is left entirely unexplained.

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

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

A single sentence that leads with the verbs and names the resource immediately, with no filler. It is efficiently structured, though it is arguably too terse for an 11-parameter tool.

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

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

For a tool with 11 parameters, a nested object, no output schema, and no annotations, this one-line description leaves an agent without the information needed to call it correctly. Nothing explains the semantics of the three actions or how the identity parameters interact.

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% across 11 parameters including a nested 'constraints' object, so the description must compensate and largely does not. It loosely gestures at 'required asset roles' and 'scene context' but says nothing about project_id, scene_id, alias vs aliases, action_text, output_kind, dependencies, or sources_hash, nor how the nested required/preferred maps work.

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 pairs three specific verbs (read, resolve, upsert) with a named resource (normalized scene context and its required asset roles), mapping directly to the action enum. An agent can tell this is the scene-context tool, though it never contrasts itself with the sibling resource tools rh_asset, rh_project, or rh_work_item that share the same CRUD-style pattern.

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

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

There is no guidance on when to choose this tool over the sibling resource tools, nor any indication of which of the three actions (read/resolve/upsert) is appropriate in a given situation. The required project_id and scene/alias identifiers are never framed as 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?

With no annotations, the description carries the full behavioral burden, and it only discloses that the catalog is 'pinned' and public. It says nothing about pagination, result ordering, auth requirements, rate limits, or the shape/cost of results.

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

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

Two sentences, front-loaded and free of filler, which is structurally sound. But for a five-parameter search tool the brevity shades into under-specification rather than genuine 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?

No annotations, no output schema, and five undocumented parameters leave major gaps for an agent to operate this tool. The description does not compensate for the missing structured documentation.

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?

Five parameters exist with 0% schema description coverage, and the description mentions none of them. query, max_price, output_type, has_media_input, and limit are entirely undocumented, so an agent must guess at semantics and units (e.g., what max_price is denominated in).

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

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

States a specific verb and resource: 'Search the pinned public RunningHub model catalog.' An agent can tell it operates on models rather than workflows or jobs, distinguishing it from rh_search_workflows and the workflow/job siblings. It stops short of naming which sibling to prefer in ambiguous cases.

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 clause 'This is discovery only, not account availability' hints at the intended usage context, implying it should be used to explore the catalog rather than to check what the user can actually run. However, it names no alternative tool for account-availability queries and gives no trigger 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, and it does disclose one real behavioral trait: constraints are never weakened, so a failed match yields no relaxed results rather than a fuzzy fallback. However, it says nothing about permissions, ranking, pagination, or whether an empty result is the failure mode — significant gaps for a 4-param search tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler; the strict-matching behavior is appended efficiently after a semicolon. It is tight, though the compression leaves the parameter and result semantics unaddressed.

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

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

For a tool with four undocumented parameters, a nested free-form object, no output schema, and no annotations, this one-line description is too thin — an agent cannot tell what a hard_constraints key looks like, what required_roles must contain, or what a no-match response returns.

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

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

Schema description coverage is 0%, so the description must compensate and it barely does: 'hard scene requirements' loosely gestures at hard_constraints and required_roles. output_kind (image/video/audio) and backend_profile_id are never explained, and no format examples are given for the nested object.

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

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

States a specific verb (Search) and resource (registered workflow library), which cleanly separates it from the model-oriented sibling rh_search_models. It does not explicitly name a sibling to contrast against, but the resource is unambiguous.

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

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

The phrase 'using hard scene requirements' implies the tool is for constraint-driven lookup, but there is no explicit when-to-use/when-not guidance and no routing to alternatives such as rh_get_workflow (fetch one by id) or rh_search_models. Usage must be inferred.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one useful negative trait ('signed upload URLs are never returned or stored as graph references'), but says nothing about permissions, mutation/reversibility, side effects, or what the call returns.

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

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

A single tightly worded sentence with the core action front-loaded and no filler. The trailing clause about URLs is dense but earns its place by conveying behavior.

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

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

For an unannotated mutation/upload tool with 0% schema coverage, four undocumented params, and no output schema, the description omits prerequisites, permissions, return behavior, and parameter meaning. It is far short of complete.

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

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

Schema coverage is 0% for four parameters. 'Registered project LoRA' faintly implies project_id and asset_id, but work_item_id and backend_profile_id receive no meaning at all, so the description largely fails to compensate for 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 states a specific verb and resource ('Upload one registered project LoRA') and names the loader flow, so an agent knows the operation. It does not, however, distinguish itself from any of the many rh_* siblings, so it earns a clear but undifferentiated 4.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The word 'registered' weakly implies a prerequisite (the LoRA must already be registered), but this is inference rather than stated 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 must carry the behavioral load. It usefully discloses that the call is side-effect free ('does not execute it'), which is the key trait for a validation tool. It says nothing about what a failed validation produces, whether errors are returned or thrown, or any auth/permission requirements.

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

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

A single sentence that front-loads the action and appends the important non-execution caveat. No filler; it could carry one more clarifying clause without bloat, but it wastes nothing.

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

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

With no annotations, no output schema, a nested free-form payload object, and 0% parameter documentation, an agent still lacks the outcome shape (what a validation result looks like) and the exact meaning of `endpoint`. A validation tool whose whole purpose is producing a verdict should describe that verdict.

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 two required parameters, so the description must compensate. The phrase 'against a public model schema' gives a plausible gloss for the opaque `endpoint` parameter, and 'a payload' names the other, but neither is pinned down (format, whether endpoint is a URL, model id, or schema id).

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

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

States a specific verb (validate) and a specific resource (a payload) plus the target of validation (a public model schema). It is clear what the tool does, though it does not explicitly distinguish itself from the similarly-named rh_validate_workflow sibling.

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

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

The clause 'this does not execute it' implicitly routes the agent away from rh_run_workflow / rh_prepare_generation for the execution path, which is useful. However, it never states when validation is required, nor does it point to rh_get_model_schema for obtaining the schema or contrast with rh_validate_workflow.

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, and it does disclose the conceptual contents of the response (structural, runnable, and backend-compatibility states), which partially substitutes for the missing output schema. However, it never states that the operation is read-only/non-destructive, whether it touches the backend or is purely local, or what happens on invalid input, so the safety and side-effect profile must be assumed from the name alone.

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

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

A single tight sentence with no filler, and the object of the operation is front-loaded before the qualifier. Every word earns its place.

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

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

For a tool with no annotations, no output schema, and zero documented parameters, the description covers only the return semantics and leaves prerequisites, distinguished siblings, and parameter meaning unaddressed. An agent would struggle to call this correctly without opening the schema and guessing at the workflow/revision distinction.

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 both parameters, and the description supplies no meaning for workflow_id or revision_id beyond the vague phrase 'local workflow revision'. It does not explain that revision_id is optional, what a revision is relative to a workflow, or the expected ID format.

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 gives a specific verb (return) and resource (structural, runnable, and backend-compatibility states for a workflow revision), so the agent knows this is a validation/reporting operation rather than a mutation. It is clear on its own, but it never distinguishes itself from the sibling rh_validate_payload or from rh_get_workflow, leaving the agent to guess which validation entry point to call.

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

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

There is no when-to-use statement, no prerequisites, and no mention of alternatives such as rh_validate_payload or rh_run_workflow. The agent must infer the context entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one important trait: creating a work item has no job/paid-task side effect. However, it says nothing about permissions, whether 'close' is destructive/irreversible, or any side effects of read/close, leaving significant gaps.

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

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

It is a single front-loaded sentence with no filler, which is structurally good, but it is disproportionately terse for a multi-action tool with 8 parameters. Brevity here reflects under-specification rather than economy.

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 three-mode (create/read/close) tool with 8 parameters, no annotations, and no output schema, the description is far too thin. An agent lacks the information needed to know which parameters each action requires or what close does to an item.

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% across 8 parameters, so the description must compensate. It only names the three 'action' enum values implicitly; chain_id, scene_id, project_id, request_kind, user_request, work_item_id, and allowed_outputs are undocumented in both schema and description.

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

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

States a specific verb set (create/read/close) and a clear resource (requested work item), and adds a scoping note that separates it from job/task-execution siblings like rh_job and rh_run_workflow. It is not a tautology.

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

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

The clause 'creation does not create a job or submit a paid task' implies this is the lightweight bookkeeping tool rather than the execution path, which partially routes the agent. But there is no explicit statement of when to prefer it over rh_job/rh_prepare_generation, and no conditions or exclusions for read vs close.

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