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

With no annotations provided, the description carries the full behavioral burden. It discloses that verification happens offline against a built-in public key, that the key is persisted to the config file, and that invalid keys are refused and left unsaved. This is substantial transparency for an activation tool, though it could mention overwriting an existing key or the exact return 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 two sentences with no filler. The first sentence front-loads the main action, source, verification method, and persistence. The second sentence efficiently covers error handling and points to the related read-back tool. Every clause adds value.

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 single-parameter tool with no output schema and no annotations, the description covers activation behavior, verification mechanism, persistence, error outcomes, and how to read the result later. The only minor gap is an explicit statement of what the function returns upon success or failure, but the phrase 'refused, unsaved' implies a feedback mechanism. Overall, it is sufficiently complete for an agent to call 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?

The schema already documents the 'key' parameter at 100% coverage, so the baseline is 3. The description adds meaningful semantics by giving the concrete key format ('MCPL1.xxx.yyy'), confirming the key comes from the checkout page, and explaining that malformed or expired keys will be rejected. This goes beyond the schema's one-line description.

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

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

The description states a specific action ('Activate a Pro key'), the exact key format ('MCPL1.xxx.yyy'), the source ('from checkout'), and the core mechanism ('verified offline against a built-in public key'). It also differentiates itself from the sibling license_status by noting that license_status reads the activation back, so there is no ambiguity about which tool does what.

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: use this when you have a Pro key from checkout that needs to be activated. It also points to license_status as the read-back tool, which implies when to use a related sibling. It does not explicitly spell out 'do not use for checking status' or list other alternatives, but the context is strong enough to avoid misuse.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It discloses that the call is local ('no network') and argument-free, and it mentions a specific explanatory behavior. The word 'Report' implies read-only, though it does not explicitly state non-destructive or permission requirements; this is adequate for a status command.

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

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

Two sentences with no filler. The first sentence lists the output fields; the second adds constraints and the sibling pointer. Every clause contributes meaningful 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 zero-parameter status tool with no output schema, the description lists the expected output fields, behavioral constraints, and the relevant alternative tool. Nothing an agent needs to call it correctly is missing.

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

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

The schema has zero parameters and the description reinforces this with 'No arguments'. It adds value by listing the reported fields, helping an agent understand what the empty input will yield. The baseline for zero-parameter tools is high, and the description meets 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 states a specific verb ('Report'), a clear resource ('this server's licence state'), and enumerates the exact fields returned. It also names the sibling 'license_activate' as the tool that does something different, so an agent can distinguish them immediately.

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 constraints: no arguments, no network, and explains a free-tier refusal. It also directs the agent to license_activate when the task is to install a key, serving as an explicit pointer to the relevant 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?

Annotations already mark it as a non-read-only, non-idempotent mutation, so the description only needs to add context. It adds the return ID format, the reusable nature, and the free-tier quota ('3 of them, runs unlimited'), which is useful operational detail beyond what annotations express.

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

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

Three short sentences front-load the action and return value, then add the follow-up tool and quota info. Every sentence earns its place 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 simple 3-param creation tool with no output schema, it covers what is created, what is returned, how to proceed with item_add, and a quota. The description is slightly ambiguous about whether category is required, but the schema resolves 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 description coverage is 100%: each parameter already has a clear description, example, and the category default is documented. The description only mentions the fields at a high level and doesn't explicitly mark category as optional, so it adds no meaningful parameter semantics beyond the schema.

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

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

The description opens with the specific verb 'Create' and names the resource 'purchase-requisition' plus the concrete outcome 'return its CL-NNNN id'. It also distinguishes itself from purchase-requisition_item_add by saying steps are added with that separate 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?

It gives clear operational context: this creates the header, and step creation is explicitly routed to purchase-requisition_item_add. It doesn't enumerate exclusions for show/list/delete, but those tools are distinct by their names and the agent can infer when to use them.

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?

Beyond the destructiveHint annotation, the description discloses that deletion is permanent, removes both the purchase-requisition and its steps, and preserves already-started runs with their own copies. This gives an agent accurate expectations about side effects and scope. It does not contradict the annotations.

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

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

Two compact sentences communicate the action, scope, permanence, and the key exception about signed runs. There is no redundancy or repeated schema content.

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

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

The critical context for a destructive operation is covered: what gets deleted, that it is permanent, and that signed runs stay readable. Return-value details are not described and no output schema exists, but this is a minor gap for a delete operation; the behavior is sufficiently clear.

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 already provides 100% coverage of the two parameters, including the confirm flag's 'no undo' meaning and the purchaseRequisition id/name format. The prose adds no additional parameter-level meaning beyond what the schema documents, so it meets the baseline but does not exceed 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 leads with a specific action and resource: 'Delete a purchase-requisition and its steps for good.' This clearly identifies what the tool operates on and its irreversible effect, and it distinguishes this destroy operation from sibling create, item, show, and list tools.

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

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

The description implies the tool should be used when a purchase-requisition must be permanently removed, and it reassures that signed runs remain unaffected. However, it does not explicitly state when to prefer this tool over alternatives, when not to use it, or compare it to related tools such as run_delete.

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

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

Annotations already mark the call as a non-read, non-destructive write, and the description adds useful behavior beyond them: it returns an id and explains the sign-off consequences of a required step. This gives the agent a better model of what happens after invocation.

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

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

Two compact sentences with no filler: the first states the action and return, the second clarifies the behavioral consequence. The key action 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?

With six parameters fully documented in the schema, the description supplies the missing return-id behavior and the required/optional sign-off semantics. It does not address selection among sibling tools, but the title and parameter schema make the operation sufficiently clear.

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 100% and each parameter already has a meaningful description. The tool description repeats only that there is text, an optional section heading, and a required flag, adding little beyond the schema. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Add one step to a purchase-requisition') and states the return value ('its I01-style id'). This makes it immediately distinguishable from sibling tools like purchase-requisition_create and purchase-requisition_item_remove.

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 intended use is implied by the imperative 'Add one step to a purchase-requisition,' but there is no explicit when-to-use versus alternatives or any exclusion condition. An agent can infer the use case, but the description does not name sibling tools such as purchase-requisition_item_remove.

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

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

Annotations already flag destructiveHint=true; the description adds that the purchase-requisition version is bumped and that active runs retain their step, so previously ticked data is not rewritten. This goes beyond the annotation in a meaningful way.

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

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

Two compact sentences front-load the core action and then add the one consequential caveat. No filler or repetition of schema details.

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

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

For a two-parameter destructive mutation with no output schema, the description provides the action, identifier format, side effects, and a safety guarantee about in-flight runs. It is enough to call correctly, though return behavior is not described.

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?

Both parameters are fully documented in the schema, including examples (I03, CL-0001). The description echoes the I01-style identifier but adds no new parameter-level semantics, so the schema carries the load.

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

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

States a specific verb ('Remove'), a precise resource ('one step from a purchase-requisition'), the identifier style ('I01-style id'), and the side effect (version bump). This clearly distinguishes it from sibling tools like purchase-requisition_item_add.

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 use case—removing a step—but does not explicitly state when to prefer this over purchase-requisition_item_add or mention exclusions. The note about runs is behavioral context, not usage guidance.

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

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

The description discloses useful behavioral details: returns at most 500 rows and sorts by newest change first. However, with all annotations set to false (readOnlyHint=false), there is no indication of safety or side effects. The description does not explicitly state that listing is read-only, which is a meaningful gap given the annotation suggests the tool might not be read-only. It also omits pagination semantics beyond the 500-row cap.

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

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

Two sentences, no fluff. The essential information (what is returned, filters, row limit, ordering) is packed into a brief, front-loaded format. Every clause earns its place; nothing is redundant or missing. This is a model of efficiency.

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 list operation with two optional filters and no output schema, the description covers the key aspects: result fields, filtering options, row cap, and sort order. Minor gaps include the lack of an explicit statement about read-only behavior (given readOnlyHint=false) and the absence of clarification on combining filters. These are not critical for a list, but a tiny bit more detail would make it complete.

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

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

Schema coverage is 100% and each parameter already has a descriptive comment. The description only paraphrases the filtering capability ('Filter by category or by a word in the name') without adding nuance, such as whether filters combine with AND or OR, or how hyphenation applies to both. Since the schema carries the full semantic weight, the description adds marginal value, warranting the baseline score.

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 lists purchase-requisitions and enumerates the returned fields (category, version, step count, runs count). It specifies filtering by category or name, which distinguishes it from sibling tools like purchase-requisition_show (for a single item) and create/delete (mutations). The purpose is unmistakable and specific.

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 when to use it (whenever you need multiple purchase-requisitions with summary info) but does not explicitly contrast with alternatives like show or run_list. It lacks explicit 'when not to use' guidance, though the scope is clear enough for an agent to infer typical usage. The presence of a list-oriented sibling set helps, but the description itself offers no direct routing advice.

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 all annotation hints false, the description carries the burden of explaining behavior. It adds useful return-behavior details (steps in order, grouped sections, required/run counts, printable as_text copy with boxes), but it does not explicitly state that the operation is read-only or has no side effects, despite the 'show' name implying it.

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

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

Two focused sentences: the first states the core output and the second the optional as_text variant. No filler, no redundancy, and the main 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 simple two-parameter show tool without an output schema, the description conveys the main return contents and the only optional behavior. It is slightly incomplete in not stating ambiguity/error handling or confirming that the call has no mutating effect, but those are minor for this 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?

Input-schema coverage is 100%, so the schema already documents both parameters. The description adds slight extra meaning by describing the as_text output as a 'blank printable copy with a box against each step,' but it contributes nothing new about purchaseRequisition beyond the schema.

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

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

The description names the exact object ('One purchase-requisition') and enumerates what is shown: its steps in order, grouped by section, required counts, and run counts. This clearly identifies the operation as a detail view for a single requisition and distinguishes it from purchase-requisition_list.

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 use case is implied: call this when you need the detailed structure of one purchase-requisition, not a list. However, it never explicitly says when not to use it or points to alternatives such as purchase-requisition_list for browsing all requisitions; the only conditional guidance is parameter-level ('Pass as_text...').

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

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

Annotations provide no behavioral hints beyond non-read-only/non-destructive defaults, so the description carries the burden. It discloses key mutation semantics: 'na counts as answered and never as passed', and that a step can be re-answered with the last answer standing. This is valuable and goes beyond the annotations.

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

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

Three tight sentences, front-loaded with the core action and accepted states, followed by important semantics about 'na' and overwriting. No filler or redundant restatement 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?

For a state-changing tool with no output schema and minimal annotations, the description covers the essential invocation context: what states are allowed, who/when attribution, the special 'na' meaning, and re-answering behavior. It does not describe the return value, but that is acceptable when no output schema exists and the operation is straightforward.

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 100%, so the baseline is 3 because the schema already documents each parameter. The description adds cross-parameter meaning by explaining how 'state' interacts with 'by'/'at', and clarifies the special behavior of 'na' beyond the raw enum description.

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

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

The description clearly states the verb ('Mark'), the resource (one step in a run), and the exact allowed outcomes (pass, fail, or na). It also distinguishes this from sibling tools like run_start or run_sign_off by focusing on step-level answering rather than run-level lifecycle actions.

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 makes the usage context clear: answer a specific step in an open run, with optional who/when attribution. It does not explicitly name alternatives or say when not to use it, but its scope is unambiguous enough that an agent can route to it correctly.

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

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

Annotations already declare destructiveHint=true, and the description adds meaningful context: deletion is permanent, cascades to every answer, and signed-off runs are refused. This goes beyond the hint by describing the refusal rule and the lack of recovery, though it omits minor operational details such as permission requirements.

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

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

Three sentences, each carrying distinct information: deletion scope, refusal condition, and the safer alternative action. There is no filler and no repetition of schema details.

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

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

For a two-parameter destructive delete with a forced confirm flag, the description plus schema and annotations cover the action, its irrevocability, cascade behavior, and an important edge case (signed-off runs). No output schema is present and none is required.

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 100%, so both 'run' and 'confirm' are fully documented in structured form. The description adds context about the irreversible scope of deletion, but it does not need to re-describe the parameters since the schema already carries that burden.

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

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

States a specific destructive verb and resource ('Delete a run for good, with every answer on it'), and clarifies the scope of deletion includes all answers. It differentiates from ordinary run operations by explicitly refusing signed-off runs, making it distinct from run_sign_off and other run-related siblings.

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

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

Gives clear guidance: use deletion for runs no longer wanted, but do not delete a signed-off run and abandon it instead. The alternative is described as 'abandon' rather than naming a specific sibling tool, so the referral is slightly implicit.

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

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

Annotations already declare the operation read-only, idempotent, and non-destructive. The description adds useful behavioral details beyond that: ordering by newest first, included fields, and the 500-row cap. It does not mention pagination, but the cap itself is transparently disclosed.

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

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

Two tight sentences: the first front-loads the core result shape and ordering, the second covers filters and the row limit. There is no filler or redundant restatement of the title.

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 read-only list operation, the description plus schema fully specify filters, result fields, ordering, and the row cap. The only minor gap is that if more than 500 runs match, the description does not say whether pagination is possible or how to page further.

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 100%, so the parameters are already fully documented. The tool description summarizes filter categories but does not add substantial new meaning beyond what the schema provides, matching the baseline for high schema coverage.

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

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

The description clearly states the operation: list runs, newest first, with their purchaseRequisition, progress, and sign-off state. It also describes available filters, making the tool's scope distinct from siblings like run_show or run_status.

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

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

The description gives clear context for when this tool is appropriate: when you need a filterable list of runs with progress and sign-off state. It does not explicitly name sibling alternatives or exclusion conditions, so it stops short of a 5.

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

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

Annotations already mark the tool readOnly, idempotent, and non-destructive. The description adds value by disclosing that output is plain text, what content is included, and that Pro can additionally write the report to out_path as a .txt file. This extends beyond the annotation-only safety profile and has no contradiction.

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 efficient sentences with no filler. It front-loads the core output ('The run as plain text') and then specifies optional Pro file-writing behavior. Every phrase contributes useful information.

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

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

For a simple, one-required-parameter reporting tool with annotations covering safety and an input schema covering all three parameters, the description explains the returned report contents and file-writing behavior. It does not specify exact formatting or error cases, but the absence of an output schema makes this acceptable 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 100%, so the parameters are already fully documented: run identifies the run, out_path is Pro-only and optional, overwrite controls file replacement. The tool description only restates the out_path behavior ('Pro also writes it...') without adding new meaning beyond the schema.

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

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

The description clearly states the tool produces a plain-text report of a run, enumerating the included contents (steps, marks, answers, notes, counts, signature). It is specific about the resource and output, though it does not explicitly contrast with run_show or run_status, so it falls short of full sibling differentiation.

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

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

The description implies when to use the tool: when a plain-text run report is needed, available on every tier, with optional file output for Pro. It does not give explicit when-not-to-use guidance or alternatives, and sibling tools like run_show and run_status suggest nearby choices, but no routing is provided.

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

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

Annotations already establish readOnly, idempotent, non-destructive behavior, so the bar is lower. The description adds meaningful behavioral context by detailing exactly what the response contains, including grouped steps, answer attribution, counts, full failures, and sign-off eligibility.

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 dense, front-loaded sentence lists the full content of the response without waste. The colon structure makes the scope clear immediately, and every clause contributes useful information.

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

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

For a read-only tool with one documented parameter and no output schema, the description adequately covers what the agent needs to know: what the tool returns and how detailed it is. Annotations cover safety and idempotency, and no pagination or side effects are relevant.

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 fully documents the single parameter, including type, max length, and an example format. The description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The title and description clearly identify the tool as showing a single run in full detail, enumerating steps, answers, timing, counts, failures, and sign-off status. This distinguishes it from run_list (listing runs) and run_status (status only) 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 implies this is the detailed single-run viewer, and the phrase 'The whole run' signals when to choose it over status or list tools. However, it does not explicitly state when not to use it or name alternatives, leaving some inference to the agent.

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 all annotation hints false, the description carries the behavioral burden and does so well: it discloses the freeze side effect, the refusal condition, the force bypass, and that exceptions persist and print on the report. This goes well beyond the structured annotations.

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

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

Two tight sentences front-load the core action and then give the key conditional behavior. No filler or repetition of schema parameter descriptions.

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 mutating tool with no output schema, the description conveys the essential call path: when it applies, which conditions block it, how force affects it, and what side effects persist. It leaves minor open questions like signing an already-frozen run twice, but the main behavior is covered.

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 already covers all five parameters, so the baseline is met. The description adds consequence-level meaning for force (bypasses refusal) and for note/exceptions (they remain on the record and print), which is not fully stated in the schema.

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

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

The description opens with a specific action ('Sign off a completed run with a name and a date, which freezes it') and clearly identifies the resource. This distinguishes it from sibling run tools like run_check, run_status, or run_start, which perform different lifecycle actions.

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

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

It states the tool is for completed runs and that normal sign-off is refused while required steps are unanswered or failed unless force is true. However, it never names an alternative tool or explicitly says when to choose something else, so the guidance is implied rather than explicit.

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

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

Annotations are all false and provide no safety or idempotency hints, so the description carries the burden. It discloses three meaningful behaviors: steps are copied (snapshot semantics), runs are free and never capped, and the return value is the run id. This goes beyond the schema, but does not cover error conditions or permission requirements, so a 4 is appropriate.

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

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

Two sentences, zero filler. The primary action and return value are front-loaded, followed by the snapshot behavior and cost note. 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?

There is no output schema, so the description must state return values—it does ('RUN-YYYY-NNNN id'). It also explains the copying behavior and cost model. It omits failure modes and preconditions, but given the moderate complexity and that the schema covers required parameters, it is sufficient for an agent to call 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 80% (4 of 5 parameters documented; note has no description). The description adds no parameter-level details beyond what the schema already provides. Since the schema does the heavy lifting, the baseline of 3 applies; the description neither adds nor detracts.

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

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

States a specific verb and resource: 'Start a dated run of a purchase-requisition' and explicitly names the return value ('RUN-YYYY-NNNN id'). This clearly distinguishes it from siblings like run_check, run_show, run_list, and run_sign_off, which all operate on existing runs rather than starting a new one.

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

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

Provides clear context on when to use: to begin a dated run of a purchase-requisition. It also explains that steps are copied into the run, implying this is the correct tool when a snapshot is needed. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

The description states that the tool changes run state ('Move a run back to open', 'abandon it'), but the annotations declare readOnlyHint=true, meaning the tool should not modify the environment. This is a direct contradiction, so the behavioral transparency score must be 1.

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 sentences with no filler. The primary operations and their use cases are front-loaded, and the important signed-off refusal constraint is stated compactly. 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?

For a four-parameter tool with a fully described schema and no output schema, the description covers the essential behavioral constraints: what state transitions are possible, when each is appropriate, and that signed-off runs are refused. It is slightly incomplete on edge-case behavior such as already-open or already-abandoned runs, but the core 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 100%, so the schema already documents run, date, note, and status. The description adds a little context for what 'open' and 'abandoned' mean, but it does not add meaningful parameter-level semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description names the exact operations ('Move a run back to open', 'abandon it') and the target resource (a run), and it distinguishes this from sibling tools like run_sign_off by stating that a signed-off run is refused. The title and description align with a clear verb+resource structure.

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

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

It gives explicit when-to-use guidance: reopen when a step must be answered again, abandon when the job did not happen. It also gives a when-not: signed-off runs are refused. However, it does not explicitly name an alternative tool such as run_sign_off for the normal close path, so it falls just short of full alternative routing.

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