Japan External Execution

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

Annotations already declare destructive=true, idempotent=true and readOnly=false, so the safety profile is covered. The description adds genuine preconditions beyond that: only pending/open requests are cancellable. It omits auth/scope requirements implied by status_token, so not a 5.

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 tightly written sentences with the positive case front-loaded and the exclusion following; every clause 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?

With annotations covering safety and no output schema to explain, the description handles purpose and preconditions well. However, for a destructive mutation with two undocumented required parameters, it leaves the caller without enough parameter 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 there are two required parameters (request_id, status_token), yet the description explains neither. status_token in particular is opaque and its role is left entirely to inference.

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

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

States a specific verb+resource ('Cancel an external execution request') and adds a state constraint ('while it is still pending manual review or open'). This is clear enough to be distinguished from cancel_verification_request, though the differentiation is carried by the noun rather than an explicit sibling comparison.

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?

Explicitly states when the tool applies ('pending manual review or open') and when it does not ('Claimed or completed work cannot be cancelled through this tool'). No alternative is named for the excluded states, so it falls short of a full routing statement.

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 annotations declaring destructive and non-readonly, the description adds valuable behavioral context: the tool can only cancel pending/open requests, not claimed/completed ones. It also implies idempotency (already in annotations) but doesn't elaborate on side effects (e.g., what happens to the request, permissions). This is good additional transparency 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?

The description is concise (two sentences) and front-loads the core action and the key constraint. Every sentence earns its place, though it could be slightly more structured with bullet points, but it's efficient.

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

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

For a destructive cancellation tool with no output schema and 0% parameter coverage, the description covers the main behavioral constraint but fails to explain the required parameters or any authentication/permission needs. It's minimally adequate but leaves gaps an agent would need to infer from the schema.

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

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

Schema description coverage is 0%, and the description provides no information about the two parameters (request_id, status_token)—their purpose, format, or how to obtain them. This is a significant gap given the low 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 a specific verb and resource ('Cancel a request') and scopes it to the Japan physical verification context via the title. It distinguishes from siblings by focusing on cancellation of a verification request, though it doesn't explicitly name alternative 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?

It provides clear when-to-use guidance ('only while it is pending manual review or open') and an exclusion ('claimed or completed work cannot be cancelled'). This gives strong context, though it doesn't name alternative approaches for non-cancellable states.

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 read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context that verification involves a human on the ground in Japan and is a fallback after web research, but it does not disclose what the check returns or how it relates to subsequent request creation.

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

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

The description is a single, front-loaded sentence that begins with 'Use when' and packs in domain, examples, and a precondition without filler. It is appropriately sized for a brief routing tool.

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

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

Given no output schema and rich annotations, the description covers when to invoke but omits what the tool actually returns (e.g., a fit assessment) and how it fits before sibling tools like prepare_verification_request or create_verification_request. An agent can decide to call it but may not know what to expect next.

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 fully documents location, objective, and evidence_requirements. The description adds no parameter-level meaning beyond what the schema already provides, which is the expected baseline when coverage is high.

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 explains the scenario in which to use the tool but does not state what the tool itself does (e.g., assesses feasibility, returns a fit result). The name and title imply a check, but the description never says 'this tool checks whether a physical verification request can be fulfilled.' It also does not differentiate this tool from sibling request-creation 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?

It clearly states when to use the tool: when an AI needs ground verification in Japan and web research or APIs are insufficient. The condition acts as an implicit when-not, but no sibling alternatives (e.g., create_verification_request) are named for comparison.

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 idempotentHint=true and destructiveHint=false, and the description reinforces the retry contract while adding genuinely new context: the request is 'manual-review' and no payment, worker hire, or fulfillment commitment is triggered. That side-effect boundary is exactly the kind of disclosure annotations cannot convey.

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 with no filler, front-loaded with the core action and followed by the retry rule and the side-effect boundary. Nothing is redundant.

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 create tool with no output schema, the description adequately covers the idempotency contract and mutation scope, but with 17% parameter coverage it leaves the agent guessing about what location, objective, and evidence_requirements should contain. Minimal but not sufficient for a tool with six parameters.

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 only 17% (just idempotency_key), and the description covers only that one parameter's reuse semantics. location, objective, deadline, constraints, and evidence_requirements are left entirely undefined in both schema and prose, so the description does not compensate for the coverage gap.

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

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

States a specific verb and resource ('Create a ... physical verification request') with scope qualifiers ('manual-review', 'in Japan'), which clearly separates it from prepare_verification_request and cancel_verification_request among the siblings. It stops short of explicitly naming a sibling to route against, so it lands just below the top tier.

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 one concrete operating instruction ('Reuse the same idempotency_key for the same logical request'), which implies retry usage, but offers no when-to-use guidance relative to prepare_verification_request or when not to call it. The 'no payment... created automatically' line sets expectations rather than selection criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds genuinely new behavioral facts: the result is only returned once the request is completed, and evidence URLs are temporary (expiring artifacts). It omits auth/credential implications of status_token and any error behavior for pending requests.

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

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

A single dense sentence, front-loaded with the action and resource, with no filler. The completion condition and return artifacts are packed in without redundancy.

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

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

There is no output schema, so the description is right to summarize the return payload, and it does so briefly. But for a two-parameter, fully-undocumented-schema status tool it omits the status vocabulary, pending-state behavior, and what status_token is for, leaving real gaps.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning and it largely does not. "External execution request" loosely maps to request_id, but status_token (a minLength-20 credential) is never explained, nor is its relationship to the request or whether it is secret.

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?

Specific verb ("Read") plus specific resource ("manual-review external execution request"), and it names the payoff (structured result plus evidence URLs). It is clearly distinguishable from request_external_execution, though it never explicitly distinguishes itself from the similarly named get_verification_status 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 phrase "when completed, receive the structured result" implies a poll-until-complete pattern, which is usable context. However, it never states when to call this versus cancel_external_execution_request, nor what to do while the request is still pending.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context — that completed requests return structured observations and *temporary* signed evidence URLs (implying expiry). It says nothing about the status_token's role or any rate limits, so it is additive but not rich.

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 tight sentence that front-loads the core action ('Read the current request state') and appends the completion behavior. No filler, though the conditional clause could be split for clarity.

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

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

With no output schema and 0% parameter coverage, the description is the only source of context, and it omits how to obtain status_token, what the un-completed states are, and URL expiry semantics. Acceptable for the return-value sketch but insufficient for a two-required-parameter polling endpoint.

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 required parameters (request_id, status_token) have 0% schema description coverage and the description does not mention either of them. The agent gets no explanation of what status_token is, where it comes from, or why a UUID plus token pair is required — the schema does all the work and even that is bare.

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 (read) and resource (current request state) plus what the completed state yields (observations and signed evidence URLs). It implicitly distinguishes itself from siblings like create_verification_request or cancel_verification_request, though it never says 'verification' or 'Japan' explicitly — that differentiation lives in the title.

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

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

There is no guidance on when to call this versus sibling status tools such as get_external_execution_status, nor any mention of polling cadence or that it should be called after create_verification_request. Usage is only implied by the verb 'Read'.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real value beyond them by disclosing the return shape ('prefilled manual-review URL only') and enumerating the side effects it explicitly does NOT perform, which is exactly the context an agent needs before treating this as a non-committing step.

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 with zero filler; the core action and its Japan/human-execution scope are front-loaded before the disclaimers. Every clause 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?

No output schema exists, and the description compensates by stating the return value (a prefilled manual-review URL). Combined with annotations covering the safety profile and 100% schema coverage for inputs, an agent has what it needs; only the sibling-routing detail 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?

Schema coverage is 100%, so all five parameters (including deadline, constraints, evidence_requirements) are already documented in the schema. The description adds only the 'Japan' locality framing and nothing about parameter format or interaction, so the baseline 3 applies.

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 ('Prepare'), resource ('Japan on-site verification request'), and scope ('human-executed store check'), which an agent can act on directly. It does not, however, explicitly distinguish itself from the sibling create_verification_request, leaving the prepare-vs-create boundary to inference.

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 negative scope ('does not purchase, submit, hire, pay, or create a fulfillment commitment') usefully implies this is a pre-commitment preparation step. But there is no explicit when-to-use guidance relative to siblings like create_verification_request or check_service_fit, so the routing decision is only implied.

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=true), the description adds critical scope context: it only creates a manual-review request and does NOT automatically hire, pay, purchase, or promise fulfillment. This directly protects the agent from assuming commitment/payment side effects, which the annotations do not convey.

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 trigger condition and examples, and closed with the crucial limitation. Every sentence earns its place with 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 write/request tool with no output schema, the description covers purpose, examples, and the non-committal nature well. The main gap is silence on how it relates to the verification-request siblings, which is exactly the ambiguity an agent faces here.

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?

At 57% schema description coverage the schema documents the key fields (objective, idempotency_key, location, max_budget_jpy), but the description adds no parameter-level meaning of its own and offers nothing for deadline, constraints, or evidence_requirements. Baseline 3 for a schema that does most of the work.

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

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

The description states a specific verb+resource — creating a manual-review request for external execution in Japan — and clarifies it is a request rather than fulfillment. However, it never differentiates itself from the sibling request tools (create_verification_request, prepare_verification_request), so an agent can't tell which request family to pick from the description alone.

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?

Strong when-to-use guidance: 'Use when an AI cannot complete a task itself and needs a human or provider in Japan,' reinforced with concrete examples (calling a business, photographing, shipping). It lacks any when-not or explicit alternative routing, which is notable given the overlapping verification request siblings.

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