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

Annotations already indicate the operation is non-read-only, idempotent, and non-destructive. The description adds the side effect of creating an explicit checkpoint, but does not explain overwrite behavior, persistence details, or any required permissions.

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 with no filler, front-loading the action and outcome. Every word contributes to understanding the tool's purpose.

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

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

For a tool with two required parameters and no schema descriptions, the description is too sparse. The agent still needs to infer how to construct state_patch_json and which run_id to target, and no usage context is given.

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 needed to compensate, but it only loosely references 'state patch'. It does not explain the required format of state_patch_json or the meaning/role of run_id beyond what the parameter names imply.

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 ('Apply') and resource ('state patch'), and states the outcome ('create an explicit checkpoint'). This clearly distinguishes it from sibling run-management tools like create_run and resume_run.

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

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

There is no guidance on when to use this tool versus alternatives. The phrase 'small state patch' implies a use case, but no conditions, exclusions, or sibling comparisons are provided.

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

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

Annotations already convey that this is mutating, non-destructive, and non-idempotent. The description adds no additional behavioral context such as side effects, state changes, required permissions, or failure behavior; it just restates the action and inputs.

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 states the action, resource, and both parameters with zero filler. 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 two-parameter creation tool with an output schema, the basics are covered. Still, the description is thin on behavioral caveats and sibling routing, making it adequate but not fully self-sufficient in the context of the orchestration-tool family.

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

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

With 0% schema description coverage, the description must carry parameter meaning, and it partially does: 'goal' is a high-level goal and 'spec_json' is an optional JSON spec. However, it gives no detail about the spec_json format, accepted fields, or constraints beyond being a JSON string.

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 ('Create'), a specific resource ('orchestrator run'), and the input shape ('from a high-level goal and optional JSON spec'). It also distinguishes itself from lifecycle siblings like resume_run and checkpoint_run by emphasizing a new run.

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 'new orchestrator run' implies this is for starting fresh rather than resuming, but the description never explicitly says when to choose this over resume_run, checkpoint_run, or plan_goal. The usage context is clear but exclusions and alternatives are left to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the workspace scope but does not explain what 'file context' includes, how paths resolve, or whether neighboring context is pulled. With annotations carrying the burden, this is an average level of additional transparency.

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

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

The description is a single sentence with no filler. The action and scope are front-loaded, and every word contributes meaning. It is appropriately concise for a tool whose safety profile and output schema are already structured.

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

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

Annotations and the output schema cover safety and return-shape expectations. However, with zero parameter descriptions and a non-obvious include_neighbors parameter, the description leaves a meaningful invocation gap. An agent cannot fully determine how to request the right amount of context or what 'file context' consists of.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining either parameter. 'paths' is somewhat inferable from 'file context', but include_neighbors is entirely unexplained. An agent cannot tell what the integer means, what default 40 implies, or how it changes the returned context.

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 read action ('Read file context') and a resource scope ('orchestrator workspace'). It is distinguishable from writing tools like write_project_memory and record_decision, though 'file context' is somewhat ambiguous and could overlap with search_project_memory or list_related_artifacts without further detail.

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

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

No guidance is given about when to use this tool versus alternatives. Sibling tools such as search_project_memory or list_related_artifacts exist, but the description does not contrast them or state any exclusion criteria. Usage context must be inferred entirely from the name and description.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds the contextual detail that artifacts are filtered by run or query, which is useful. However, it does not disclose what 'related' means, whether results are complete or paginated, or any behavior beyond the read-only nature already captured by annotations.

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

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

The description is a single clean sentence without filler. It front-loads the verb and resource, making it immediately scannable. Every word contributes to the core meaning.

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

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

While the output schema covers return structure and annotations cover safety, the description is too sparse to be fully actionable. It lacks optionality rules for the two parameters, behavior when arguments are omitted, and definition of 'related.' For a tool with two optional parameters and zero schema descriptions, more context is needed.

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 carries the burden of explaining parameters. It only hints that 'run or query' correspond to run_id and query, but does not clarify defaults, optionality, or how the two parameters interact. An agent would not know if passing both is supported or if neither results in an error.

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 'List artifacts related to a run or query' clearly states a specific verb (list) and resource (artifacts) with a scope qualifier. It does not explicitly differentiate from sibling tools like search_project_memory, but the operation it describes 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?

No guidance is provided on when to use this tool versus alternatives such as search_project_memory or get_file_context. There are no hints about when a run_id should be provided, when a query is appropriate, or whether both can be combined. The usage context is implied only by the phrase 'related to a run or query.'

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that this produces a blueprint from a goal and optional spec, but does not disclose additional behavioral traits such as whether it persists anything or how output is delivered. No contradiction with annotations.

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

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

A single, front-loaded sentence with the core action stated first and no wasted words. It is highly scannable and immediately useful.

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 and annotations cover return values and side-effect safety, while the description covers purpose and inputs. However, it lacks guidance on how planning relates to the sibling run-lifecycle tools and leaves spec_json semantics 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?

Schema description coverage is 0%, so the description must compensate. It paraphrases the parameters as 'high-level goal' and 'optional JSON spec', but does not explain the expected format of spec_json, its constraints, or how it influences the blueprint. This adds little beyond the parameter names themselves.

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 ('Generate'), a specific resource ('large-app execution blueprint'), and the inputs ('high-level goal and optional JSON spec'). It is clearly distinguishable from siblings like create_run or resume_run, which concern run execution rather than planning.

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

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

The description implies an early planning use case but gives no explicit guidance on when to use this tool versus siblings such as checkpoint_run or create_run. It does not state ordering, prerequisites, or when planning is not appropriate.

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

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

The description adds no behavioral detail beyond the annotations: it does not say whether entries are append-only, whether duplicate calls overwrite, what permissions are needed, or how the decision is stored. It is consistent with the annotations, so not a contradiction, but it contributes nothing beyond them.

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 focused sentence with no filler. Key qualifiers ('high-value architectural or implementation') are front-loaded and help scope the tool.

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

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

For a six-parameter tool with no schema descriptions and sibling tools that overlap in purpose, this is too thin. It does not explain parameters, selection criteria, or how it differs from related tools; the existing output schema only removes the need to document return values.

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

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

Schema description coverage is 0%, and the description does not explain any of the six parameters. While parameter names are somewhat self-explanatory, required fields like run_id and node_id are not given meaning, and the description does not compensate for the missing schema descriptions.

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

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

The description identifies a specific action ('record') and resource ('decision'), and qualifies the kind as 'high-value architectural or implementation.' It does not explicitly compare with record_failure_mode or write_project_memory, so it falls short of full differentiation.

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

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

No guidance is given about when to use this tool versus siblings such as write_project_memory or record_failure_mode. The phrase 'high-value' implies a selection criterion, but there are no explicit when-to-use or when-not-to-use instructions.

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?

Annotations already disclose idempotency and non-destructiveness, and the description aligns with readOnlyHint=false by indicating a write operation. The description adds little beyond 'reusable' to characterize behavior, but given the annotation coverage this is adequate.

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

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

The description is a single concise sentence with no filler, front-loading the core purpose immediately. Every word contributes to understanding the tool's function.

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

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

Despite annotations covering idempotency and an output schema being present, the description leaves important invocation details unclear, especially what constitutes a 'signature', what run_id and node_id refer to, and when this is preferred over sibling recording tools. This is insufficient for a 5-parameter tool with zero schema descriptions.

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 provides no meaning for run_id, node_id, signature, summary, or artifact_uri. With low schema coverage the description needed to compensate, but it does not explain what any parameter represents.

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 ('Record') and a clear resource ('reusable failure pattern or bug signature'). It distinguishes this tool from siblings like record_decision or write_project_memory by naming the failure-mode domain 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 description implies clear usage context: use this tool when you need to persist a failure pattern or bug signature for reuse. It does not explicitly mention alternatives like record_decision or write_project_memory, so it lacks the when-not/exclusion guidance needed for a 5.

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?

Annotations already cover read-only, destructive, and idempotent traits, so the description does not need to restate those. It adds useful behavioral context beyond the schema: the run continues until completion, pause, or failure, which helps an agent understand the tool's execution behavior. No contradiction with annotations.

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

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

A single, front-loaded sentence conveys the purpose and execution boundaries with no filler. Every word contributes meaning, and the most important constraint—what causes the run to stop—is included without extra prose.

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

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

For a one-parameter tool with an output schema and annotations, the description covers the essential behavioral contract well. The only notable gap is the absence of explicit guidance about which run states are valid for resumption, but this is minor given the clarity of 'Resume an orchestrator run.'

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

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

Schema coverage is 0%, and the description does not directly explain run_id beyond naming the 'orchestrator run' entity. The parameter name and schema title are largely self-explanatory, so the agent can probably infer which ID to supply, but the description adds no detail about where the ID comes from or its 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 uses a specific verb ('Resume') and identifies the target resource ('an orchestrator run'), then narrows the contract by stating the possible terminal states: completion, pause, or failure. This clearly distinguishes it from sibling tools like create_run or checkpoint_run.

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 word 'Resume' implies this tool is for already-created or previously paused runs, and the terminal-state clause clarifies what happens after invocation. However, it never explicitly states when to prefer this tool over alternatives such as checkpoint_run or create_run, leaving usage context to inference.

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

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

Annotations already cover readOnly, idempotent, and non-destructive behavior, so the description does not need to repeat those. It adds that searching is by query and type filters, but does not disclose default behavior like status='active' or limit semantics. No contradiction with annotations.

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

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

A single, front-loaded sentence with no filler. It states the action, target, and primary input efficiently.

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 presence of an output schema and rich annotations reduce the need to explain return values and safety. However, with 0% schema description coverage, the minimal description leaves the exact filter semantics and default behavior under-specified. It is adequate for basic invocation but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It names 'query' and vaguely mentions 'optional type filters', but does not enumerate or clarify the kind, status, or limit parameters, nor their defaults. This leaves most parameter meaning to inference.

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 and resource: 'Search project memory', with a concrete mechanism ('by query string and optional type filters'). It clearly distinguishes itself from siblings like write_project_memory and record_decision, which are write-oriented.

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 verb 'Search' implies this is the retrieval tool compared to write_project_memory, but the description gives no explicit when-to-use guidance, prerequisites, or exclusions. Usage is implied 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?

Annotations already cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the description does not need to restate those. It adds some context by emphasizing durability and provenance, but it does not explain important behaviors such as overwrite/supersede semantics or what happens when the same key is written again.

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

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

The description is a single, front-loaded sentence with no filler. It is easy to scan, though the brevity sacrifices necessary detail.

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

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

This tool has 9 parameters, 5 required, no schema descriptions, and no parameter guidance in the description. An agent cannot confidently determine allowed kind values, the expected format of value_json, or the semantics of supersedes, so the description is not complete enough for reliable 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%, so the description must compensate by explaining parameters, but it only hints at provenance for run/node fields. The meanings of kind, key, value_json, status, confidence, supersedes, and artifact_id are left entirely to the agent to infer from names alone.

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

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

The description uses a specific verb ('Write') and identifies the resource ('durable memory entry with provenance' written to 'the backing store'), so an agent can tell this is a persistence operation. However, it does not distinguish itself from sibling tools like record_decision or record_failure_mode, which may also write memory entries.

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

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

The description gives no guidance about when to use this tool versus alternatives such as record_decision, record_failure_mode, or search_project_memory. There are no stated use cases, prerequisites, or exclusions, leaving the choice of tool to inference.

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