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

No annotations are provided, so the description must disclose behavior. It only says 'analyze', which implies read-only but does not state whether it has side effects, requires special permissions, or what side effects might occur. No behavioral detail beyond the verb is offered.

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 wasted words, but it is under-specified to the point of uselessness. This is not effective conciseness; it is a lack of necessary content. The single sentence does not front-load any actionable 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?

Despite having an output schema, the description is completely inadequate for a tool with 3 parameters and no annotations. It does not explain the tool's purpose, when to use it, parameter meaning, or any behavioral context, leaving the agent with no basis 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 description does not explain any of the three parameters (target, target_platform, application_path). The mention of 'provider invocation' and 'couplings' does not map to any parameter semantics, so the agent has no clue how to fill them.

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

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

The description states a verb 'analyze' and a resource 'provider invocation and adjacent tool/output couplings', but this is vague and does not clarify what specific analysis is performed. It does not distinguish from sibling analysis tools like analyze_prompt or analyze_regressions, and the term 'couplings' is undefined.

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

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

No guidance is given on when to use this tool versus any of the 32 siblings. There is no mention of conditions, prerequisites, or alternatives, leaving the agent to guess based solely on the name and vague 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a conservative, no-inference approach, but says nothing about side effects, return behavior, limitations, or permissions. This is only a thin behavioral hint.

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 redundancy, and the core idea is front-loaded. However, it is under-specified rather than efficiently complete, so it earns only a midscore.

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 documentation is not strictly required. Still, the description gives an agent no way to choose this tool among many prompt-related siblings given the large sibling list, and the absence of annotations compounds the issue.

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

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

Schema description coverage is 0% and the description adds no parameter-level detail. An agent only sees a string named 'prompt' with no explanation of expected format, content, or constraints.

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

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

Describes a specific action (analyze) on a specific resource (prompt characteristics), and adds a distinctive qualifier ('conservatively', 'without inference'). It doesn't explicitly differentiate from sibling tools like validate_prompt or analyze_invocation, 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 guidance about when to use this tool versus alternatives. The description does not state what scenarios warrant conservative analysis, nor does it name any sibling tools to prefer for validation, comparison, or inference-based tasks.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'Return a structured categorized regression report' signals a read-only reporting behavior, but it does not disclose side effects, prerequisite data requirements, or how categorization is determined. This is adequate but 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?

The description is one clean, front-loaded sentence with no wasted words. It immediately states the action and the output, which is ideal for the tool's simple interface.

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 and may document the report structure, the input side is underspecified. The single required 'run' parameter is an unconstrained object, and the description does not clarify what an evaluation run must contain or how to obtain it. This leaves meaningful ambiguity for an agent trying to invoke the tool.

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

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

Schema description coverage is 0% and the schema only provides a generic 'run' object with additionalProperties true. The description adds that 'run' is an evaluation run, which is useful, but gives no detail about required fields, expected structure, or how the run object should be supplied.

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 ('Return'), resource ('structured categorized regression report'), and target ('evaluation run'). It is clear and focused, though it does not explicitly contrast with similar reporting/analysis siblings such as analyze_prompt or generate_migration_report.

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 a clear context for use: analyzing regressions from an evaluation run. It does not explicitly state when not to use it or name alternative tools, but the intended scenario is reasonably clear.

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, yet it only reveals that the combination is deterministic and that agent agreement is not treated as evidence. It does not disclose side effects, required permissions, return behavior, or what 'combine' produces beyond the name.

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

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

The description is very concise and front-loaded with the core operation, and the warning is packed into a short second clause. It is not bloated, though the brevity leaves important information unwritten.

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 an output schema existing, the description is incomplete for a tool with three required nested-object parameters and zero parameter documentation. An agent would know the general intent but not how to structure the inputs or what behavioral guarantees apply.

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 none of the three parameters have descriptions. The text references 'research' and 'review' but never clarifies their structure or roles, and 'request' is entirely unexplained.

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

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

The description states a specific action ('deterministically combine') and the resources ('research' and 'review'), and the title 'Build Research Consensus' supplies the intended result. It is not a tautology and is distinguishable from siblings like validate_evidence_review, though the output format is left implicit.

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

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

There is no statement of when to use this tool versus alternatives, no preconditions, and no named sibling. The caveat 'agent agreement is not evidence' hints at a use context but does not tell an agent when to choose this tool over validate_research_result or generate_migration_research_request.

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 cover behavioral traits. It discloses that the tool fails closed if stages still need an agent, and implies it does not do hidden work. It mentions immutability and expiring overlay, which are significant behavioral traits. However, it does not detail what failure returns or specific side effects beyond the fail-closed behavior, but the core transparency is present.

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

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

The description is concise and front-loaded: the first line states the core purpose and key characteristics (immutable, expiring overlay). The second line provides crucial prerequisites and failure behavior. It is well-structured with no redundant information, every sentence earns its place.

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

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

Given the tool's complexity (finalizing a session overlay with guardrails) and the existence of an output schema, the description is fairly complete. It covers the main requirements (artifacts exist, fail-closed) and outcomes (immutable, expiring). It lacks details on parameter semantics and specific return behavior, but the presence of an output schema reduces the need for return documentation, and the essential context is present.

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 parameter-specific details. The tool has 4 parameters (run_dir, now, ttl_days, shadow_canonical) with a required run_dir, but the description doesn't explain the meaning of any beyond implicit inference from the description (e.g., ttl_days likely relates to expiration). This is a gap that forces the agent to guess at parameter semantics.

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

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

The description clearly states the tool's purpose: to finalize a run workspace into an immutable, expiring session overlay. It identifies the specific verb ('finalize') and the resource ('run workspace' to 'session overlay'), which helps distinguish it from other migration-related tools. However, it does not explicitly differentiate itself from sibling tools like 'finalize_migration', requiring the agent to infer the distinction.

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

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

The description gives clear context on when to use: artifacts must already exist, and any stage needing an agent fails closed. It implies this is for the final step after research/review artifacts are prepared. It does not explicitly mention when not to use it or list alternatives, but the prerequisites are clearly stated, making the usage context clear.

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 behavioral burden. It discloses that the tool does not perform live research and works from reviewed facts, which implies a read-only, offline behavior. However, it does not mention side effects, staleness, or failure behavior, leaving some transparency 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?

The description is a single focused sentence with no redundancy or filler. It is appropriately compact for a simple tool, though the terseness leaves some semantic 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?

Despite having an output schema, the tool lacks annotations and has zero parameter documentation in the schema. The description does not define 'lifecycle facts,' explain the identifier input, or give enough selection criteria among the many sibling tools. It is not complete enough for an agent to confidently invoke it.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only hints at 'a fixed date' (matching as_of_date) but never explains the required 'identifier' or the format/meaning of the date. This is insufficient for correct invocation.

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

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

The description gives a specific verb ('Interpret') and resource ('reviewed lifecycle facts'), and adds a fixed-date scope plus 'without live research.' It is clear enough to distinguish the tool from live-research siblings, though it does not explicitly name alternatives.

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

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

The phrase 'without live research' provides clear contextual guidance: use this tool when you need reviewed lifecycle facts at a fixed date rather than live research. It does not explicitly list alternatives or when-not-to-use conditions, but the context is reasonably clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the output contract (explicit discrete states, including unsupported and unknown), which is useful, but it says nothing about whether the tool has side effects, calls external services such as live pricing, requires auth, or how unsupported/unknown are determined.

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 description is tightly written, front-loads the key result (explicit comparison states), and has no filler. It is concise but under-specified; the short length is appropriate, yet the one sentence cannot carry the full guidance burden.

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

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

Despite having an output schema, the tool still lacks essential context: 7 parameters with 0% schema documentation, no annotations, and no description of how source/target/endpoint/platform/pricing combine. An agent cannot confidently construct a correct call from the available text 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%, so the description needed to explain what source/target mean and how endpoint/platform/pricing parameters affect the comparison; it does none of that. The property names are somewhat self-explanatory, but the text adds no semantic value beyond the raw 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 uses a specific verb ('Return') and names the explicit output states (same/different/unsupported/unknown), so an agent can tell this is a discrete-state comparison tool rather than a free-form diff. It does not literally state that source and target are models, but the title and sibling context make that reasonably clear. It stops short of 5 because compare_outputs could be confused without more explicit object-of-comparison wording.

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

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

There is no guidance about when to choose this tool over compare_outputs, resolve_model, or the other comparison/migration siblings, and no mention of prerequisites or exclusions. The description only states what the tool returns, leaving the agent to infer when it is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'deterministically' which is a behavioral trait, but does not disclose whether the operation is read-only, has side effects, requires specific permissions, or what the result structure is. This is a significant gap for a tool with no annotation safety profile.

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, which is concise and direct. However, it is under-specified, lacking necessary details about inputs and behavior. It is not verbose, but the brevity comes at the cost of completeness, making it borderline adequate.

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 means return values are covered, but the description omits critical context: when to use this tool, what the parameters mean, and any behavioral notes. Without annotations or parameter descriptions, an agent would struggle to call this correctly. It is incomplete for a two-parameter tool with no safety annotations.

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

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

Schema coverage is 0%, meaning the parameters are undocumented in the schema. The description only hints that the two parameters form a 'paired source/target' relationship, which provides minimal meaning. It does not explain what constitutes a source or target result or how they should be structured. The description fails to compensate for the lack of parameter documentation.

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

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

The description states a specific action ('compare') and a specific resource ('one paired source/target evaluation result'). This is clear enough to distinguish it from siblings like compare_models, which likely compare models rather than evaluation results. However, it does not elaborate on what 'compare' entails or what the output looks like, leaving some ambiguity.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or provide any context for selection. An agent would have to infer that it is for comparing a pair of evaluation results, but no explicit usage guidance is given.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not state whether this creates a persistent record, what side effects occur, what permissions are needed, or what the output represents. 'Scan locally' suggests a read-like action, while the tool name implies creation, leaving behavior unclear.

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

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

The description is short but under-specified. It does not front-load the core purpose or add usable information; the single sentence is more cryptic than concise.

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

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

With six parameters, nested objects, an output schema, no annotations, and many sibling tools, this description is far too incomplete. It omits what a migration research request is, how the parameters relate, when to use it, and what the tool actually accomplishes.

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 clarify any of the six parameters: application, run_id, source, target, as_of, or topics. Phrases like 'locally' and 'user-scoped' are not mapped to the schema, so the agent gets no meaningful parameter 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 contains action verbs ('Scan', 'bound') and hints at an operation on research facts, but it never explicitly says it creates a migration research request or what that entails. It is vague rather than tautological, and it does not distinguish this tool from any 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?

There is no guidance about when to use this tool instead of the many sibling tools. 'Scan locally' implies some local scope, but no explicit conditions, prerequisites, or alternatives are provided.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does disclose that the estimate is recurring and uses canonical/checked-in pricing, implying read-only calculation behavior. However, it does not clarify side effects, assumptions, or what happens if pricing data 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?

The description is a single front-loaded sentence with no filler. Every word adds meaning: 'recurring,' 'token cost,' and 'checked-in canonical pricing' all convey scope and data source.

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 five required parameters, no annotations, and no schema descriptions, the one-sentence description is not sufficient for an agent to invoke the tool confidently. The output schema exists but does not compensate for the missing input semantics and behavioral context.

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

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

Schema description coverage is 0%, and the description does not explain any of the five parameters. Parameter names like source, target, requests, and token counts are suggestive, but the description adds no units, constraints, or clarification about what values are expected.

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 operation: 'Estimate recurring token cost' and scopes it to 'checked-in canonical pricing.' This clearly distinguishes the tool from live-pricing siblings like query_live_pricing, and it names the resource being estimated.

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?

'From checked-in canonical pricing' gives clear context for when to use this tool: when the estimate should be based on the static/checked-in pricing source rather than live quotes. It does not explicitly name alternatives or exclusions, so it stops short of a full 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?

With no annotations, the description carries the behavioral burden, and it does meaningful work: it discloses the output location, the report contents, the inclusion of files lacking adaptation deliverables, and the idempotent/re-runnable property. It does not mention permissions, overwrite behavior, or prerequisites, but the core side effects are well characterized.

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-loaded with the primary action. Each sentence earns its place: the first names the outputs and location, the second clarifies report contents, and the third communicates idempotency.

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

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

The description adequately explains what the tool produces and that it is safely re-runnable, and an output schema exists to define return values. However, it leaves gaps around the 'now' parameter, the expected state of run_dir, and how this tool fits into the migration workflow relative to its many 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%, and the description adds no parameter-level explanation. 'run_dir' is inferable from context, but the optional 'now' parameter is entirely unexplained, leaving an agent uncertain whether it is a timestamp override, a freeze time, or something else.

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: it 'write[s] the run's manifest, report, and adaptation change log under output/.' This clearly identifies the deliverable set, but it does not explicitly distinguish itself from the sibling generate_migration_report, so an agent may need to infer the difference.

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

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

The description gives clear invocation context: 'Re-run it any time; it always reflects the current submissions,' which tells the agent the tool is safe and idempotent to call repeatedly. However, it does not mention when to choose this over alternatives like generate_migration_report or start_migration.

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 of disclosing side effects and behavior. It only characterizes the corpus as 'deterministic,' but does not state whether this mutates state, writes files, validates inputs, or is idempotent.

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

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

The single sentence is efficient and contains no filler, which is good for front-loading. However, it is under-specified to the point that conciseness comes at the expense of usefulness.

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, the tool has nested, loosely constrained objects (cases and migration_plan are additionalProperties objects), no annotations, and no usage context. The description is far too thin for an agent to invoke the tool correctly or understand what the resulting evaluation suite contains.

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 was expected to compensate, but it only alludes to 'evaluation corpus' for cases and 'migration manifest' for migration_plan. It adds no detail about the contents of cases, the structure of migration_plan, the optional name parameter, or how parameters interrelate.

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 ('Bind') and two concrete resources ('deterministic evaluation corpus', 'migration manifest'), which makes the core operation clear and distinguishes it from siblings like run_migration_eval or generate_migration_plan. However, 'bind' is somewhat opaque jargon and alternatives are not named.

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 related tools such as run_migration_eval, compare_outputs, or generate_migration_plan. There are no preconditions, no exclusions, and no workflow 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 provided, the description carries the full burden of behavioral disclosure. It does state that the tool does not write files, which is a key side-effect trait, but it does not mention whether it reads files, requires network access, or any other behavioral aspects. The description is truthful but minimal, earning a middle score.

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 fluff, and the key information (application-level, no file writing) is front-loaded. While it could be longer to address other dimensions, the conciseness itself is appropriate; the issue is more about completeness than 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?

For a tool with 8 parameters, no schema descriptions, and no annotations, the description is far too sparse. It does not explain the meaning of 'actionable,' the nature of the manifest, or how parameters influence the result. Although an output schema exists (so return values need not be described), the lack of usage and parameter guidance makes the definition incomplete 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?

The input schema has 0% description coverage and the tool description does not explain any of the 8 parameters (e.g., application_path, source, target, or optional fields). Since the description must compensate for the schema's lack of information, this complete omission is a severe deficiency.

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

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

The description clearly states the tool generates an 'actionable application-level migration manifest' and explicitly notes it does so 'without writing files.' This specifies the verb, resource, and scope, and differentiates it from siblings like generate_migration_report (report) and generate_session_migration_plan (session-level) by the 'application-level' qualifier.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or references to sibling tools, leaving the agent to infer usage solely from the name and generic description. With many closely related tools in the sibling list, this is a notable gap.

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

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

With no annotations, the description must fully disclose side effects and operational traits. It says 'generate a human-readable report', which implies a read-like operation, but it never states whether this tool actually runs migrations or modifies anything. It also fails to mention any safety, auth, or side-effect details. The disclosure is minimal and incomplete.

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 fluff or redundancy. However, it is under-specified and does not provide enough structural detail to be genuinely useful. It is appropriately sized in length but not in content, so it only partially earns its place.

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

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

Given a tool with 8 parameters (3 required) and no output schema visible, the description is drastically incomplete. It does not explain what the 'integrated migration workflow' entails, what inputs are needed, what the report contains, or any relationship to the migration process. An agent has virtually no context to call this tool correctly.

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

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

The schema has 0% description coverage, and the description adds no meaning for any of the 8 parameters. It does not explain what source, target, application_path, or the optional fields represent, nor how they are used to generate the report. The burden falls entirely on the description, and it fails to compensate.

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

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

The description clearly states a verb (generate) and a resource (human-readable report), and it conveys the output type. However, it does not differentiate from sibling tools like generate_migration_plan or generate_session_migration_plan, which also produce migration-related outputs. It is clear but lacks distinction.

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

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

The description provides no guidance on when to use this tool versus the many sibling migration tools. It does not mention any preferred scenario, exclusions, or alternatives. An agent receives no help in selecting between this and other plan/report tools.

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

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

No annotations are present, so the description must convey side effects and behavior. 'Plan' hints at non-execution, but it never states whether any mutation occurs, what inputs are needed, how the overlay affects the result, or what the plan contains.

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 short sentence with no filler, and the core purpose is front-loaded. However, conciseness comes at the cost of omitting useful behavioral and parameter context.

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 seven parameters, four required, and no annotations, this description is too thin. It provides no guidance on how to invoke it, what makes this session-based version different from alternatives, or what the output plan covers.

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 offers no explanation of the parameters. Terms like 'canonical registry' and 'session overlay' do not map to source, target, application, or session_run_dir, leaving the agent to guess.

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 and resource: planning a migration over the canonical registry plus one run's session overlay. It is not the same as a generic migration plan because of 'session overlay,' which helps distinguish it slightly from siblings like generate_migration_plan.

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 only implied: the 'session overlay' phrasing suggests this is for migration planning involving a single session run, unlike the general generate_migration_plan. There is no explicit when-to-use/when-not-to-use guidance 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 disclosure burden, and it does well: it discloses the result shape (2-5 options, consequences, evidence URLs), the required presentation behavior, the 'never choose' policy, and the reporting of previously recorded decisions including stale ones. It does not disclose side-effect status, auth, or error behavior, but the described operation appears read-only and the output behavior is clearly specified.

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 front-loaded with the core purpose and each subsequent sentence adds essential behavioral or usage detail. It is compact enough while communicating the exact user-interaction contract, output contents, and downstream next step.

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 an existing output schema, the description does not need to restate return values and instead adds valuable context: per-blocker interaction, verbatim presentation, no user substitution, and stale-decision reporting. The only notable completeness gap is the undocumented optional 'now' parameter, which prevents full self-sufficiency for a caller.

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 define parameters. 'run_dir' can be inferred from 'started run', but the optional 'now' parameter is entirely undocumented, including its format and effect. Since the description compensates for only one of the two parameters, it leaves a material 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?

Description states a specific action and resource: it returns questions and evidence-backed options for each unresolved blocker of a started run. It also distinguishes itself from downstream tools like record_blocker_decision by mentioning the exact call to make, rather than recording the decision itself.

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

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

Clear usage context is given: use for each blocker of a started run, present options verbatim one at a time, and never decide for the user. It points to record_blocker_decision as the subsequent call, but it does not explicitly list when-not-to-use or compare against sibling tools as alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it returns a profile, but does not explain side effects (likely none), performance characteristics, whether it errors if the identifier is not found, or the semantics of 'validated' and 'local registry'. This is insufficient for a tool with no annotation support.

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

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

The description is extremely concise (one sentence), but conciseness is not the same as adequacy. It is not front-loaded; it is just a minimal phrase that could be a tautology. It is not padded with fluff, but it is under-specified, which is a different issue. A score of 3 is generous because it is at least short.

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 the tool has only one parameter and an output schema, the description fails to clarify the tool's role in the larger migration workflow. Given the sibling names, this tool likely serves a specific function in model profiling, but the description does not explain what 'validated' or 'local registry' mean, nor how it relates to other tools. The output schema might help, but it is not visible to the agent without additional context.

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

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

The schema coverage is 0% and the description does not explain the 'identifier' parameter beyond the schema's type. It does not mention that the identifier likely refers to a model name or ID, or how it should be formatted. With a single parameter, the description should at least clarify what the parameter represents, but it adds no value.

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 is minimal: 'Return a validated local registry model profile.' It specifies a verb ('Return') and a vague resource ('model profile'), but it does not define what 'validated' or 'local registry' means, nor does it distinguish from siblings like 'resolve_model' or 'compare_models'. It merely restates the tool name without useful 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?

The description offers no guidance on when to use this tool versus alternatives such as 'resolve_model' or 'check_model_lifecycle'. It does not mention any context, prerequisites, or exclusions. An agent would have no idea whether to call this or a sibling for a given task.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that the tool produces one bounded, scope-isolated prompt pair per remaining scope, imposes a strict agent-isolation constraint, and requires downstream validation and registry building. This goes well beyond a generic 'get prompts' statement and tells the agent what to expect and what to do next.

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 two purposeful sentences: the first states the deliverable, the second specifies the exact workflow and constraints. There is no filler or repetition of schema fields, and the most important behavior is front-loaded.

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

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

For a single-parameter tool with an output schema, the description covers the input, the generated artifact, the operational constraints, and the next step in the pipeline. Nothing essential is missing for an agent to invoke and follow through 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?

The input schema only declares `run_dir` as a string with no description and 0% schema coverage, so the description must compensate. It does by explicitly referencing `<run_dir>/request.yaml`, which tells the agent that `run_dir` is the path to the run directory containing the request file. It adds the key semantic meaning the schema lacks.

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 ('renders') and a concrete resource ('researcher and reviewer prompts for a run's research request') tied to `<run_dir>/request.yaml`. It clearly differentiates this from siblings like build_research_consensus or validate_evidence_review by framing it as a prompt-generation step, not an analysis or validation step.

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 explicit usage context: run one prompt per remaining scope with a separate agent, write YAML artifacts, validate them, then call build_session_registry. It also includes an explicit exclusion ('never let one agent research two scopes or review its own research'). It does not name alternative tools for comparison, but the procedural guidance is strong enough to direct correct use.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses useful internal behavior: the worklist is derived from the migration plan, uses the session overlay when built, and distinguishes shared_prompt_guidance from per-task guidance. However, it does not state whether the operation is read-only/idempotent, what side effects (if any) calling it produces, or any auth/precondition requirements beyond 'started migration run' — for an un-annotated tool this is a visible gap.

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

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

The description is front-loaded well with the core purpose and call-once instruction, but the body is dense — the guidance-distribution detail, submission workflow, and finalize_migration routing are packed into long multi-clause sentences. It is informative but not easy to scan; the procedural detail could be tightened without losing 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?

The workflow is well contextualized: it describes what the worklist contains (prompt tasks with shared vs. per-task guidance, file tasks with the unchanged=true escape hatch) and how it fits between submit and finalize steps. Return shape is covered by the presence of an output schema, and the derivation semantics (session overlay) add useful depth. The main gap is the unexplained now parameter, which keeps this from a 5.

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 explains neither parameter. run_dir is only weakly implied by 'a started migration run', and the now parameter (nullable string) is never mentioned at all — an agent cannot determine whether to pass it or what it controls. With 0% schema coverage and zero parameter explanation in the description, this is a clear shortfall.

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

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

The description clearly states the resource and action: a per-file adaptation worklist for a started migration run, with the front-loaded instruction to call it once. It distinguishes itself from the sibling submission tools (submit_adapted_prompt, submit_adapted_file) and finalize_migration by positioning itself as the listing step in the workflow. Minor gap: it never explicitly says it 'lists/returns tasks' — the noun 'worklist' implies it, but the primary verb is implied rather than stated.

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?

Provides explicit when-to-use context: call once at the start of adaptation, and explicitly states when NOT to re-list ('Submission results confirm acceptance, so re-listing between submissions is unnecessary'). It routes follow-up behavior to the right siblings — submit_adapted_prompt, submit_adapted_file with the unchanged=true option, and finalize_migration for remaining gaps. Strong procedural guidance, though it doesn't name an alternative listing tool explicitly.

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 burden of behavioral disclosure. It explicitly says 'review-only' and 'Return ... recommendations,' which signals a non-mutating, analysis-oriented tool. However, it does not disclose output limits' behavior, potential errors, or any side effects beyond that, leaving moderate 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?

The description is a single sentence with no filler. It front-loads the core behavior ('Return bounded, review-only recommendations') and then adds the evidence source, making it appropriately sized and efficiently structured.

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

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

Given three parameters, zero parameter descriptions, no annotations, and a large sibling set, this description is insufficient for correct invocation. It does not explain the optional parameters, nor does it clarify how this tool differs from related migration-planning or analysis tools, despite having an output schema to cover return shapes.

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 opaque parameters. It only hints at 'regression evidence,' loosely mapping to the required regression_report, but gives no meaningful explanation of limits or candidate_runs. The agent cannot infer what shapes or semantics those optional parameters expect.

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 ('Return') and resource ('bounded, review-only recommendations') tied to 'observed regression evidence,' so an agent can infer the tool produces evidence-based suggestions. However, it does not explicitly differentiate from sibling tools like analyze_regressions or generate_migration_plan, leaving some ambiguity.

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

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

The phrase 'from observed regression evidence' implies the tool should be used when a regression report is available and review-only recommendations are needed. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives among the many migration-related siblings, so the guidance remains 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 provided, the description must carry the full burden of behavioral disclosure. It only says 'prepare' and 'without editing application files,' which is vague—it doesn't explain what the tool actually does (e.g., creates a contract object, returns data, requires permissions) or what side effects might occur.

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

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

The description is a single, concise sentence with a clear verb and subject. It is front-loaded with the primary action and includes a relevant constraint, making it easy to parse. However, its brevity comes at the cost of completeness, which is penalized elsewhere.

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

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

Despite having an output schema, the description is grossly incomplete for a tool with five parameters and no annotations. It lacks parameter explanations, usage context, and any indication of when to call it in the migration workflow. An agent would not know what inputs to provide or how this tool fits with siblings like prepare_prompt_migration or generate_migration_plan.

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

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

Schema description coverage is 0%, and the description adds no information about the five parameters (application_path, source, target, source_platform, target_platform). The names provide some hints, but the description does nothing to clarify their meaning, types, or relationships, forcing 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 states a clear action ('Prepare a target invocation contract') and adds a key differentiator ('without editing application files'), which distinguishes it from file-editing tools. However, it doesn't explicitly distinguish from similar siblings like prepare_prompt_migration, so it's not a perfect 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 use this tool versus alternatives. No mention of prerequisites, conditions, or exclusions. The description gives no context about the migration workflow, leaving the agent to guess whether this should precede generate_migration_plan or start_migration.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that the tool does not rewrite the prompt, which is a meaningful behavioral constraint. However, it does not disclose what the output specification contains, whether any side effects occur, or whether the tool performs validation or analysis. The description is honest about the non-mutating nature but lacks depth about the actual 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?

The description is a single sentence that is concise and front-loads the core purpose. It avoids redundancy and does not waste words. However, it is so brief that it sacrifices useful detail, so it earns a 4 rather than a 5.

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

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

The tool has 7 parameters, no annotations, and an output schema, but the description does not explain what the output specification looks like, what the required parameters represent, or how this tool fits into the migration workflow. The output schema exists but the description should still clarify the tool's role relative to siblings like generate_migration_plan. The description is too thin for the tool's complexity.

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 7 parameters, but it does not explain any of them. The description mentions 'prompt migration specification' but does not clarify what 'source', 'target', or 'prompt' mean in this context, nor the optional parameters like source_path, source_role, or platform fields. The agent must infer parameter semantics entirely from names and the schema, which is insufficient for a tool with 7 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 verb ('prepare') and resource ('prompt migration specification') and adds a key constraint ('without rewriting the prompt'). This distinguishes it from sibling tools like generate_migration_plan or run_migration_eval, though it doesn't explicitly name an alternative. The phrase 'without rewriting the prompt' clarifies the tool's non-destructive intent, which is helpful for an agent deciding between this and a migration execution tool.

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

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

The description implies the tool is for preparing a specification rather than executing a migration, which gives some context. However, it does not explicitly state when to use this tool versus siblings like generate_migration_plan or prepare_invocation_migration, nor does it mention any prerequisites or follow-up steps. The 'without rewriting' phrase hints at a non-execution role, but the guidance is not explicit enough for an agent to confidently choose between this and similar planning 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 burden and does disclose a key behavioral trait: it does not edit canonical files. Yet it does not explain what the tool does with the plan, whether it persists anything, or if it has other side effects, so transparency is partial.

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

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

The description is a single short sentence that front-loads the verb 'Plan' and the critical constraint 'without editing canonical files'. There is no redundant wording or 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?

The definition is too thin for a tool that accepts a complex nested parameter and sits among many similarly named migration-planning siblings. It lacks parameter details, usage context, and relationships to alternatives, leaving an agent without enough information to invoke it 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% and the only parameter 'research' is an open object with no documentation. The description's phrase 'supplied evidence' hints at what the parameter should contain, but it does not specify structure, required subfields, or expected format, leaving agents to guess how to populate it.

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 'Plan' with a clear resource 'registry update' and adds a crucial boundary 'without editing canonical files' that distinguishes it from mutation tools. While it does not explicitly name sibling alternatives, the non-editing qualifier sharply narrows its role.

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?

'from supplied evidence' implies the tool should be used when evidence is available and a planning step is needed, providing some contextual guidance. However, it does not mention any alternatives or conditions for when not to use this tool, leaving the choice among the many sibling tools ambiguous.

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 that the tool is read-only regarding registry facts, which is helpful, but it does not disclose that it makes an external network call to OpenRouter, potential latency, failure modes, or the need for network access. This is a significant omission for a live inquiry tool.

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

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

The description is a single sentence with no waste, but it is concise to the point of under-specification. It front-loads the key purpose and the non-mutating caveat, which is efficient. However, brevity sacrifices critical behavioral and parameter information, so while the structure is concise, the content is incomplete.

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

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

The tool is complex (network call, live data) and has an output schema, but the description is minimal. It adds only the 'fact unchanged' caveat, but it omits the source of the data, the meaning of 'opt in', the expected output structure, and any prerequisites. Given the lack of annotations and 0% schema coverage, the description is not adequate for an agent 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%, so the description must compensate, but it provides no parameter semantics. The schema defines 'identifier' and 'timeout' with no description, and the tool description does not explain what the identifier refers to (e.g., model ID or pricing ID) or what the timeout controls. This is a critical 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 states the specific action ('opt in to an OpenRouter pricing inquiry') and clarifies that it does not modify canonical registry facts, which distinguishes its purpose from tools that update the registry. However, it does not explicitly name sibling alternatives that might be confused with it, and the term 'opt in' is somewhat idiosyncratic.

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 clearly implies when to use this tool: when live pricing is needed, and it explicitly says that canonical registry facts are unchanged, which signals when not to use it (when updates are intended). However, it does not explicitly mention alternative tools or provide explicit exclusions, so there is some gap in guiding the agent away from similar inquiry 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 behavioral disclosure burden. It does reveal meaningful traits: 'hard-filter' implies exclusion of incompatible models and 'deterministically rank' implies reproducible ordering. However, it does not clarify what 'compatible' means, how ranking works, or whether the operation is read-only.

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

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

The description is a single efficient sentence with no filler, and the key behavioral terms are front-loaded. It is appropriately concise, though it sacrifices useful guidance for brevity.

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 10 optional parameters, no annotations, and no parameter descriptions, this one-sentence description is insufficient for an agent to call the tool correctly. It does not explain filtering criteria, ranking rationale, or how parameters interact, and the presence of an output schema does not compensate for missing input semantics.

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

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

Schema description coverage is 0%, and the description adds no parameter-level meaning. Some parameter names like region, platform, and provider are self-explanatory, but others such as migration_goal, application_path, and source_platform remain ambiguous with no description support.

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

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

The description states a specific action—'hard-filter and deterministically rank'—and a clear resource, 'compatible registry models.' It conveys the tool's core function, though it does not explicitly distinguish it from siblings like compare_models or resolve_model.

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

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

The description gives no guidance on when to use this tool versus alternatives such as compare_models, resolve_model, or get_model_profile. There are no usage scenarios, prerequisites, or exclusions, leaving the agent to infer appropriateness 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?

With no annotations provided, the description carries the full behavioral burden and does so thoroughly. It discloses persistence, decision-specific side effects (migration.yaml updates, injected adaptation tasks, downgrade to accepted decision), and the result's content. This level of detail is exceptional for an unannotated tool.

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

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

The description is dense but highly organized, front-loading the core action and durability before explaining decision-specific behavior. Every clause adds distinct information, with no filler or repetition of the schema.

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 no annotations and zero schema descriptions, the description covers the core behavior, side effects, prerequisites, and result contents. An agent has enough to invoke the tool correctly and anticipate consequences, especially given that an output schema already exists.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for blocker_id and option_id (source from get_blocker_resolutions) and rationale (required for accept, never default). However, it does not explain run_dir, now, or decided_on, though those are more inferable or optional.

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

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

The description states a specific action and resource: 'Record the user's decision for one blocker'. It also flags durability, which distinguishes this write operation from read-only siblings like get_blocker_resolutions. The purpose 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 description explicitly tells the agent that blocker_id and option_id must come from get_blocker_resolutions, and that accept options require the user's own rationale and are never a default. It does not explicitly list when not to use the tool, but the triggering condition ('user's decision for one blocker') is clear.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses that matching is deterministic and tolerates vague input, and it explains the three possible `status` values with what they mean (show candidates to user for needs_confirmation). This adds meaningful behavioral context beyond the schema. It could mention error handling or edge cases, but it covers the core behavior well.

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 two paragraphs, with the key directive front-loaded in the first sentence. The second paragraph adds essential usage guidance and status explanation. It is concise but not overly terse; every sentence contributes. Slight redundancy: 'Always check here' and the normalization details could be merged, but it's acceptable.

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 an output schema (though not shown in this snippet) which likely documents the return structure, so the description doesn't need to explain return values. The description explains the statuses that are core to the tool's behavior. However, given the complexity of resolving vague input, the description could provide more detail on what constitutes 'vague' or examples, but it is adequate for an agent to understand when to use it and how it behaves.

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 doesn't elaborate on any parameters except 'identifier' (implicitly via 'identifier to resolve'). The description doesn't explain the purpose of `endpoint` or `platform`, even though they are optional and could influence resolution. That's a gap. However, the description mentions 'vague platform names' which hints at platform's role, but no parameter-specific details. Given 0% coverage, the description provides minimal help for 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 verb ('Match') and resource ('identifier against the local registry') and mentions its purpose of resolving vague input. It clearly indicates the tool normalizes variations like regional prefixes and version suffixes, which helps distinguish it from siblings like get_model_profile or compare_models, though it doesn't explicitly name a 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 description explicitly instructs 'Always check here before researching a model', giving clear when-to-use guidance. It describes the normalization behavior (regional prefixes, version suffixes, spacing, vague platform names) that triggers the need for this tool, which is a strong usage context. It doesn't explicitly state when not to use it, but the directive is unambiguous.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the tool uses 'user-owned local provider credentials,' which is useful, but it does not say whether this operation executes provider calls, has side effects, incurs costs, requires special permissions, or how it behaves on failure.

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 one tight sentence with no waste and front-loads the main action. However, its brevity crosses from concise into under-specified, so it does not quite earn a 5.

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

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

The tool accepts three complex nested objects and has no annotations, so the description leaves too much to inference. The presence of an output schema covers return values, but the lack of guidance on configuration structure, execution semantics, or credentials limits completeness.

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 clarifying parameters. It does not explain what sits inside suite, source_config, or target_config, nor how they relate to one another. The parameter names alone are insufficient for three complex nested objects.

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 'Run' and names the object 'source and target,' but it does not clarify what 'source and target' actually are (models? configs? prompts?). The title 'Run Migration Eval' adds context, but the description alone does not clearly differentiate this tool from siblings like generate_eval_suite or compare_outputs.

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

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

The description provides no when-to-use guidance, prerequisites, or alternatives. The only implicit hint is that this runs an evaluation with user-owned local provider credentials, but it does not explain when an agent should choose this over the many related 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 behavioral disclosure burden. It adds useful detail about automatic discovery and prompt_sources becoming explicit high-confidence sources, but it does not explicitly state side effects, permissions, or whether the scan is read-only, although 'scan' implies non-mutating 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?

The description is compact and front-loaded: the core purpose appears in the first sentence, and the optional parameter explanation is separate and minimal. There is no filler or repetition of schema 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 simple scanner with an output schema, the description provides enough invocation context: target application, optional prompt files, and their semantics. The main gaps are explicit path handling and usage timing, but these are minor given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains prompt_sources well, including relative path semantics and its role in supplementing automatic discovery, but the required path parameter is only implied via 'application root' and not explicitly documented.

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 ('scan'), resource ('local Python application'), and output ('normalized coupling inventory'). This clearly distinguishes the tool from the migration and analysis siblings, which focus on individual prompts, invocations, or migration steps.

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 provided, and no alternatives are named. An agent must infer the tool's applicability from the phrase 'coupling inventory' or from sibling tool names, which is indirect.

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 well: it discloses that nothing is written when identifiers need confirmation, that a workspace is created otherwise, that research is written only when missing or stale, and that the result includes candidates or next_steps. This gives an agent a clear model of side effects and conditional 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?

Three sentences, front-loaded with the tool's purpose, then conditional behavior, then side effects and next-step guidance. Every sentence adds substantive information and there is 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?

For a complex, annotation-free tool with 12 parameters and zero schema descriptions, the description covers the core workflow and side effects very well. It is not completely exhaustive because advanced parameters are left unexplained, but the behavioral flow is detailed enough for an agent to make a reasonable first 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. It does add meaning for source/target as model identifiers, application_path in the workspace path, output_dir, and research to some extent. But many parameters (as_of, run_id, prompt_sources, source_endpoint, target_platform, etc.) remain unexplained, leaving 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 opens with a specific verb and resource: 'Start a guided migration run' and immediately positions the tool as 'the preferred entry point for a full migration.' This clearly separates it from sibling tools that generate plans, research requests, or finalize migrations, even though no sibling is named 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 gives clear usage context: use this when starting a full migration. It also explains the conditional flow and says next_steps will name the tools to call next. However, it does not explicitly state when NOT to use this tool or name alternative entry points.

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 transparency burden. It discloses deterministic checks, the output destination, that the application tree is never modified, and that prompt files are rejected. This is strong behavioral disclosure for a submission/mutation tool.

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

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

The description is dense but every sentence earns its place: purpose, format constraint, validation behavior, no-modification guarantee, and the unchanged alternative. It is front-loaded with the main purpose and then adds critical operational details without fluff.

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

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

The description covers the core behavior, constraints, destination, and sibling routing, which makes the tool usable. It loses one point because several parameters still lack semantic explanation, and with no annotations the overall definition is not fully self-contained for a 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 coverage is 0%, so the description must compensate. It explains adapted_content and unchanged well, but leaves run_dir, source_path, rationale, changes, and new_file without any added meaning beyond their names and types. An agent has to guess the exact expected semantics for five of seven 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 opening sentence states a specific verb ('Store') and resource ('one finalized post-adaptation application file') with clear scope. It also explicitly distinguishes itself from submit_adapted_prompt by saying prompt source files are rejected here and should go there.

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 tells the agent when to submit normally, when to use unchanged=true, what format is required, and explicitly rejects prompt files while naming the correct sibling tool. This gives clear when/when-not guidance with alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It thoroughly explains validation on decoded values, rejection of cosmetic edits, handling of unchanged submissions, rejection of blockers and structural drops, output location, and report inclusion. This is exceptionally transparent for a complex tool.

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

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

The description is long but every sentence earns its place—it covers validation rules, edge cases, and side effects without fluff. It is front-loaded with the core purpose and then systematically details constraints. The structure is logical and dense, though it could be tightened by removing some redundancy (e.g., repeated emphasis on rejection).

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 parameter descriptions in schema, and significant complexity, the description is remarkably complete. It covers validation criteria, rejection conditions, unchanged handling, structural rules, output destination, and report integration. An agent has everything needed to call it correctly. Return format is not mentioned, but an output schema likely covers that.

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 explain parameters. It explicitly clarifies `changes`, `unchanged`, `adapted_prompt`, and `allow_restructure`, including the constraint that `unchanged=true` requires an empty `adapted_prompt`. `run_dir`, `source_path`, and `rationale` are not individually described but are inferable from context (output path, source file, and report mention). The critical parameters are well covered, with minor gaps on the obvious ones.

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

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

The description opens with 'Validate and store one refined prompt for the target model,' which is a specific verb+resource statement. It clearly distinguishes from siblings like submit_adapted_file (for files) and other prompt-analysis tools. The purpose is unambiguous and immediately actionable.

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

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

The description provides clear conditions for using the tool: when to pass unchanged=true, when allow_restructure is needed, and what gets rejected. It does not explicitly name alternatives or state 'use this when X, use that when Y,' but the context of a final submission is implied. It gives enough guidance for an agent to decide when to invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Check' implies a read-only comparison, but the description does not state whether the tool mutates state, how coverage is determined, what happens on failure, or what the output represents.

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

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

The description is a single, front-loaded sentence with an active verb and no filler. It is appropriately concise for a straightforward validation operation, though the brevity leaves behavioral and contextual details to other dimensions.

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 opaque nested objects and no annotations, the description is too thin. It does not explain what 'covers' means, what a valid evidence review looks like, or how the validation result should be interpreted, leaving the agent without enough context to invoke 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?

The schema provides only generic object types with 0% description coverage, so the description must compensate. It adds a useful semantic mapping: review corresponds to the evidence review and research to the research artifact. However, it does not explain required properties, nesting, or the structural relationship between the two objects.

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 action ('check') applied to a specific resource ('independent evidence review') against another resource ('research artifact'). It conveys the tool's role in verifying coverage, though it does not explicitly distinguish it from siblings like validate_research_result.

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 such as validate_research_result or build_research_consensus. No workflow context, prerequisites, or exclusions are provided; the description only implies a verification scenario.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It says the validation is 'static' but does not explain side effects, failure modes, what happens when assumptions conflict with registry facts, or whether this is a read-only operation. The description provides only a high-level intent, not enough behavioral transparency for a tool with no annotation safety hints.

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 compact and readable. It loses a point because 'statically validate' is slightly jargon-heavy and the sentence carries insufficient detail, but as a standalone statement 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 tool has five parameters, zero annotation coverage, and no parameter documentation in the schema. Although an output schema exists, the description still fails to convey what inputs are expected beyond the two required ones, when to use the tool, or what the validation guarantees. This is inadequate for correct invocation in an agentic 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 by explaining the five parameters. It only hints at 'prompt assumptions' and 'target registry facts,' which loosely maps to prompt and target, but it never explains source_path, target_endpoint, or target_platform. The optional parameters remain completely undocumented, leaving an agent without enough meaning to populate them correctly.

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

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

The description states a clear action ('validate'), a specific object ('prompt assumptions'), and a reference point ('target registry facts'). The qualifier 'statically' adds mode-of-operation detail. It does not explicitly name sibling tools, but the action is specific enough to separate it from broader analysis tools like analyze_prompt.

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 choose this tool over siblings such as analyze_prompt, validate_evidence_review, or run_migration_eval. There are no exclusions, prerequisites, or alternative conditions. Usage context is only weakly implied by the verb 'validate'.

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

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

With no annotations, the description carries the full burden of behavior disclosure, yet it only reveals that the operation is deterministic and gate-like. It does not state whether the tool is read-only, what happens when a result fails the gate, or what side effects or return behavior to expect.

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 delivers the core action and resource in the fewest possible words.

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

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

At 0% parameter documentation and no annotations, a one-sentence description is insufficient for a tool with two opaque nested objects and a large sibling set. The description needs to clarify the role of 'request,' the nature of the gate result, and when this tool applies.

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 prose only weakly hints at the 'research' parameter via 'one research artifact.' The 'request' parameter is entirely unexplained, and the nested object structures have no semantic 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 names a concrete operation ('run a deterministic scope/policy gate') and a specific resource ('one research artifact'), making the core function understandable. It is somewhat generic relative to sibling validate tools, but the artifact-and-gate framing distinguishes it enough.

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 about when to use this tool versus validate_prompt, validate_evidence_review, or other validation siblings. The description states what the tool does but not under what conditions an agent should choose it.

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