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

No annotations are provided, so the description carries the burden. It does disclose the returned signal set (token, fingerprint, unreviewed flag), which is useful behavioral context for a read, but it says nothing about permissions, side effects, or whether reading is safe/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?

A single front-loaded sentence with no filler; the verb and resource lead. It is slightly list-like but every clause names a distinct returned artifact.

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?

An output schema exists, so return values needn't be re-explained, and the description's mention of token/fingerprint is a bonus. However, for a tool whose only parameter is undocumented and whose usage in the save/validate workflow is unstated, the definition 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?

There is one required parameter, config_path, with 0% schema description coverage, and the description never explains its format or expected value (path relative to what? a config id?). With low coverage the description should compensate, and it does not.

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

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

The description uses a specific verb ("Read") and resource ("config") and enumerates what comes back: edit token, fingerprint, and unreviewed status. That is enough to distinguish it from config_save and config_validate, though it never names those siblings 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?

There is no explicit statement of when to call this versus config_validate or config_save. The mention of an "optimistic edit token" implies a read-before-write flow, but the agent has to infer that; 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?

Without annotations, the description carries the full burden of behavioral disclosure, and it addresses only part of it. It does not say whether saving overwrites an existing file or what a failed validation does, and it never explains that expected_sha256 is a concurrency guard against stale writes. The revision rule it states is useful, but mutation and safety semantics are missing.

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

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

Two sentences, with the action and its timing stated first, and no wasted words. The second sentence is dense and its phrase 'config/output/scene revision' is left unexplained, which slightly weakens clarity but not 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?

This is a mutation tool with a nested free-form payload, zero parameter documentation, and no annotations. Even though an output schema exists, the description omits the return contract, failure behavior, and overwrite semantics. For a save operation with a concurrency token, it does not tell the agent enough to call the tool confidently.

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 all three required parameters. The description never explains that config_path identifies the target, what shape the nested, free-form data object is expected to have, or that expected_sha256 is the precondition hash. This leaves an agent to work out the most important write parameters entirely from the schema structure.

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 concrete verb and resource: it validates and saves a config draft. That is much clearer than the bare name. However, it does not distinguish 'save' from the sibling tool config_validate, so the agent cannot tell from this description alone why it would choose one over the other.

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?

'before any scene generation' implies the timing for this call, and 'changed scenes require a new config/output/scene revision' hints at a precondition. Beyond that, the description gives no explicit when-not guidance and does not route to config_validate, or to config_read, stage_start, or the other siblings. 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a validation/check operation but does not state whether it is read-only, what happens on hash mismatch, whether it mutates state, or what permissions are needed; the output schema offsets return-value gaps but not behavioral ones.

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 and front-loads the check operation, but the second clause is opaque and poorly connected to the first. It is concise without being sufficiently informative.

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 two undocumented parameters, no annotations, and no schema descriptions, the description should do more to explain inputs and validation behavior. The presence of an output schema helps only with return values, not with the core 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 never mentions config_path or resolve_objects. The vague phrase 'resolve exact instance selectors' does not clearly map to the resolve_objects parameter, so no meaningful parameter semantics are added.

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 phrase 'Check schema/source hashes' gives a concrete validation action, so the basic purpose is inferable. However, the second clause ('resolve exact instance selectors and visibility before assembly') is cryptic and does not clearly distinguish this tool from siblings such as config_read, config_save, or environment_inspect.

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?

'after inspect' provides only an oblique sequencing hint, likely referencing environment_inspect, but there is no explicit guidance on when to use this tool versus config_read/config_save or when not to use it. The agent is left to infer the 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 exist, so the description carries the full burden. It does disclose two useful traits: discovery is non-mutating (no install/upgrade) and unsaved windows are excluded. It omits output character, cost, permissions, and scope of 'local'.

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

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

Two short sentences, front-loaded with the action and scoped by a limitation. Nothing wasted, though the second sentence is cryptic without context on what 'unsaved windows' refers to.

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?

An output schema exists and no parameters are required, so the definition needn't explain return values. Still, it lacks the boundary against inventory_query and the meaning of 'local' and 'unsaved windows', which an agent needs to pick this tool confidently.

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 takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; no parameter claims are made or contradicted.

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 verb+resource: 'Discover local software'. But 'local software' is undefined — which software, at what granularity, is left to inference. Sibling inventory_query plausibly overlaps, and the description does nothing to separate the two.

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 guidance is a negative constraint ('without installing/upgrading it'), which is really a safety statement rather than a usage rule. No when-to-use scenario and no alternative named among inventory_query or config_read.

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 does add genuine domain context (metres as units, ground-corrected unity_origin/unity_bounds vs raw origin/native preserving source zero). It does not disclose that the operation is read-only, what auth/config is required, how paging behaves, or anything about the returned payload.

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?

Three short sentences with no padding, but the brevity comes at the cost of clarity: the coordinate-system jargon is front-loaded ahead of any plain statement of what the tool returns. Efficiently sized but under-specified rather than tight.

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?

An output schema exists, so return values needn't be described, but for a 5-parameter tool with zero annotation coverage the description omits the meaning of config_path and model_id (both required), the filtering role of name_contains, and any read-only/permission posture. An agent could not confidently construct a call from 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% across 5 parameters (config_path, model_id, limit, offset, name_contains), and the description explains none of them. It instead discusses unity_origin/unity_bounds, which are not even input parameters, so it fails to compensate for the coverage gap; only "Page" loosely hints at limit/offset.

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?

"Page current instances/visibility" is close to a restatement: it names a paging behaviour and an ambiguous object ("instances/visibility") without saying what an instance is or what this inventory covers. Nothing distinguishes it from siblings like environment_inspect or config_read.

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 statement of when to use this tool versus environment_inspect, config_read, or any other sibling, and no prerequisites or exclusions. The only quasi-instruction ("Use ground-corrected unity_origin/unity_bounds for config") is about interpreting output, not about tool selection.

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 does disclose two traits beyond the schema: the returned log is bounded (tail-only) and a running/unknown state is not a green light to redispatch. It omits whether the call is read-only/idempotent, what happens if job_id is unknown or expired, and whether the receipt is durable after completion.

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 terse sentences with the operation stated first and the caution second; both earn their place and there is no filler. It is arguably over-compressed for a 0%-documented schema, but nothing is wasted.

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?

An output schema exists, so return values need not be described. Still, for a tool with zero annotation coverage and zero parameter documentation, the description leaves real gaps: the meaning of "receipt," the identity semantics of job_id, and the failure mode for unknown or pruned jobs.

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. "Bounded log tail" clarifies that log_lines controls tail length (versus, say, full log retrieval), but job_id is never explained — whether it is the job's own id, a workflow id, or a receipt handle — leaving the required parameter ambiguous.

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 ("Read") and two concrete resources ("persistent receipt" and "bounded log tail"), so the operation is identifiable. However, it does not name or contrast itself with the related siblings like job_reconcile or workflow_status, and "persistent receipt" is somewhat in-house jargon an agent may not resolve.

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 line "Running/unknown is not authorization to redispatch" implies a workflow rule (poll/verify via this tool rather than relaunching), which is a useful hint. But it never explicitly says when to call job_get versus job_reconcile, workflow_status, or standalone_launch, so the guidance is inferred rather than 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?

With no annotations, the description must carry the full behavioral burden, and it does disclose one important trait: it never clears unresolved work, and it only reads terminal evidence. It does not say whether the call mutates stored state, whether it is idempotent, what permissions are needed, or what happens if evidence is missing.

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

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

Two short sentences with no filler, and the trigger condition is front-loaded before the scope constraint. The terseness borders on under-specification given the undefined term 'reconcile', but no sentence is wasted.

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?

An output schema exists, so return values need not be explained. Still, for an unannotated tool that appears to touch job state, the description leaves open whether it writes anything, how it fails, and how job_id maps to the described evidence — gaps that matter for correct 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 description coverage is 0% and the single parameter job_id is completely undocumented in both schema and description. The description implies a worker/job context but never states that job_id identifies the stopped worker's job or what form it takes.

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 the operation (reconcile) and its scope (current terminal engine/Unity evidence), and ties it to a trigger (after a worker stops). However, 'reconcile' is never defined operationally, so an agent cannot tell exactly what state change or verification it performs. It also does not distinguish itself from nearby siblings such as job_get or workflow_status.

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 timing condition 'After a worker stops' is a genuine usage cue, which is better than nothing. But there is no explicit statement of when not to use it, no alternative tool named for related job-state queries, and no prerequisite that the job must be in a terminal state.

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 behavioral burden and does disclose meaningful traits: it preserves dirty scenes (won't discard unsaved work), refuses other running scenes (a precondition/guard), and only stops this config's preview. What is missing is any explanation of what start vs capture vs stop actually do and what permissions or side effects each entails.

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 only two sentences, but the second is a run-on clause stack ("Preserves dirty scenes, refuses other running scenes; stop only this config's preview before another stage") whose meaning is hard to parse. It is reasonably front-loaded but unstructured for the amount of behavior it tries to convey.

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?

Although an output schema exists (so return values needn't be described), the tool is a 3-parameter stateful control operation with no annotations and 0% schema coverage. The description omits action semantics and parameter meanings, leaving significant gaps for an agent to act on start/capture/stop 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 compensate, but it leaves parameters largely unexplained. The action enum (start/capture/stop) is never mapped to behavior, the sample boolean is not mentioned at all, and config_path is not described. The scattered mentions of "capture" and "samples" do not fully document the three 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 states a specific resource and context ("a current saved scene in Play Mode") and mentions capturing screenshots, advancing frames and performance samples, which conveys the general intent. However, it never explains the start/capture/stop action model central to a tool called preview_control, and it does not distinguish itself from siblings like stage_start or standalone_launch. The purpose is broadly inferable but not crisp.

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 operational constraints ("refuses other running scenes", "stop only this config's preview before another stage") but never states when an agent should choose this tool versus the sibling stage/job/review tools. There is no explicit when-to-use or when-not-to-use guidance, only implicit context.

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

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

No annotations are present, so the description carries the full burden. It does disclose genuine behavioral traits: input files remain read-only, paths resolve against the workspace root, and the result is a draft with entries/doors populated only later. It omits failure behavior, overwrite semantics for an existing config_path, and any permission requirements for a 7-required-parameter mutation.

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?

Three short sentences, front-loaded with the core action and followed by constraints. Little waste, though 'URP/Input System/Pipeline' stacks jargon that could be stated more plainly.

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 7 required parameters, zero schema coverage, and no annotations, the description is far too thin — most required inputs are unexplained. The existence of an output schema excuses it from describing return values, but the input and behavioral gaps remain large.

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 9 parameters, so the description must compensate and largely does not. It loosely maps 'saved SKPs' to sources and 'Unity project' to unity_project, but says nothing about config_path, python_executable, unity_cli, native_library, font, ground_elevation, or 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?

States a concrete verb and resource: 'Create a new draft config from saved SKPs.' The word 'draft' usefully distinguishes the output from a finished config. It never names or contrasts with the sibling config_save/config_read, so the agent gets no explicit disambiguation.

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?

'Provide an existing URP/Input System/Pipeline Unity project' states a prerequisite, and 'Entries/doors are filled after inventory' implies a sequencing relationship with inventory_query. However, there is no explicit when-to-use versus config_save, no statement of what to do if a config already exists, and no named 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?

No annotations are provided, so the description carries the full behavioral burden. It does add some context beyond the schema, such as paged results and a cryptic note that 'Missing reports remain missing,' but it does not explain permissions, error behavior, or consistency guarantees. The result is partial behavioral disclosure rather than a complete picture.

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 and front-loaded with the core action. The second sentence about missing reports is terse and somewhat puzzling, but it does not add bloat. Overall it is appropriately sized.

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 output schema helps cover return values, but the tool still has four parameters with 0% schema descriptions and no annotations. The description does not explain config_path, the report enum, or pagination defaults, and its behavioral notes are too vague to fill the 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 for four undocumented parameters. 'Paged' weakly hints at limit/offset, and 'one Unity report' hints at the report parameter, but config_path is unexplained and the report enum values are not described. The description adds little real parameter meaning.

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

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

The description clearly states a specific verb and resource: 'Read one Unity report.' It also adds scope with 'paged checks' and 'exact input fingerprint.' It does not explicitly distinguish itself from nearby siblings like config_read or inventory_query, but the purpose is otherwise 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 guidance on when to use this tool versus alternatives. The description does not say what situations call for report_read, nor does it mention exclusions or prerequisites. Usage is only implied by the verb 'Read.'

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses statuses and some review rules, but it does not state whether this is a write/mutation tool, whether records are overwritten, what permissions are required, or how errors 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?

The description is compact and front-loads the core purpose before the category-specific checklists and usage rules. The line-based structure is somewhat dense, but there is little wasted text.

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 complex tool with five required parameters, a nested observations object, two enums, and no annotations, the description is only partially complete. It covers the kind-specific observation categories and evidence rule, but omits method semantics, config_path meaning, and behavioral/side-effect 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%, so the description must compensate. It adds useful meaning for 'kind' by mapping each kind to specific observation categories and clarifies that 'evidence' should explain not_applicable items. But it never explains the 'method' enum or the required 'config_path' parameter, leaving two of five required parameters undocumented.

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 says to 'Bind actual observations to current sources/config/scene/build' and lists review statuses and categories, which implies it records review outcomes. However, 'bind' is vague, and it does not explicitly state that this tool creates or records a review, nor does it distinguish itself from siblings such as config_validate or report_read.

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

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

It gives domain-specific usage rules: source must pass, not_applicable items must be explained in evidence, and unobserved behavior must not be marked passed. It does not, however, say when to use this tool versus alternatives like environment_inspect, config_validate, or report_read, so the guidance is implied rather than explicit.

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 discloses that the job is persistent, returns promptly, and that operation IDs should be reused only for identical requests, but it omits side effects, permissions, failure behavior, concurrency implications, and what the start operation actually creates.

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 short and front-loads the key action and idempotency rule. The stage list is compact and each sentence contributes useful 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?

An output schema exists, so return-value explanation is not required. The description covers the stage sequence and operation-ID policy, but it leaves key context gaps for a no-annotation start tool, including config_path meaning, sample semantics, and relationship to job/status siblings.

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

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

Schema description coverage is 0%, so the description needs to compensate. It adds meaning for stage ordering and sample-applicable stages, and explains operation_id reuse, but config_path remains undocumented and sample is only implied through the stage list.

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

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

The description states a specific verb and resource: starting a persistent local job, with the stage workflow named. It is clear what the tool does, but it does not explicitly distinguish itself from sibling tools such as standalone_launch or job_reconcile.

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

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

It gives useful context for operation_id reuse and lists the stage order, which implies how to invoke the tool. However, it does not say when to prefer this tool over siblings or mention prerequisites, exclusions, 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?

No annotations are provided, so the description carries the full behavioral burden. It does not explain side effects, whether the launched app persists, required permissions, failure behavior, or what happens to prior app instances; the verification caveat is too thin to compensate.

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 and front-loaded, with no filler. The second sentence is somewhat cryptic, but it arguably earns its place as a caveat about launch versus verification.

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?

An output schema exists, so return values need not be explained. However, with no annotations, an undocumented required parameter, and no sibling differentiation, the description is not complete enough for an agent to invoke this tool confidently.

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 is one required parameter, config_path, with 0% schema description coverage, and the description never explains what config_path should contain or how it relates to the launch. The phrase 'this run's current verified Mac build' implies context but does not define the parameter.

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

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

The description states a specific verb and resource: launching the run's current verified Mac build as a new app instance. It is clearer than a bare name restatement, but it does not distinguish this tool from nearby lifecycle siblings such as stage_start or preview_control.

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

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

There is no explicit guidance on when to use this tool, when not to use it, or which sibling tool is the alternative. The sentence 'Launch request is not input verification' is a caveat, 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 carries the full behavioral burden and falls short. 'Rehash' could imply recomputation or caching side effects, yet the description never states whether this is a read-only summary, what it reads, or whether it writes anything. No mention of permissions, refresh costs, or how config_path influences behavior.

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

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

It is a single compact sentence with no padding, but 'Rehash current artifacts' is a wasteful, unclear lead that buries the real purpose behind ambiguous terminology. Front-loading the summarization targets would make it stronger.

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?

An output schema exists, so return values needn't be explained, but the description still lacks the basics an agent needs: what artifacts are summarized, what a 'stage' means here, and what config_path supplies. For a workflow-status tool with siblings covering config, jobs, and reports, this leaves the selection decision underspecified.

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 single parameter config_path has 0% schema description coverage and is never mentioned in the description. Unlike the zero-parameter baseline, this tool has one undocumented required parameter, and the definition does nothing to clarify what a config path points to or what format it takes.

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 summarization targets (stage evidence, manual observations, coverage, delivery readiness), which implies a status/reporting tool, but 'rehash current artifacts' is vague jargon and the resource (workflow) is never stated plainly. It does not differentiate itself from siblings like report_read or job_get, leaving ambiguity about which summarizer to pick.

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 versus report_read, job_get, job_reconcile, or config_read. There are no prerequisites, no exclusions, and no conditions that select this tool over its siblings — the agent must infer 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.