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 implies this is a read-only help tool, but doesn't specify details like whether it requires authentication, rate limits, or what format the help is returned in (e.g., text, list, structured data). For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 short, front-loaded sentences that efficiently convey the purpose and usage without any wasted words. Every sentence adds value: the first states what it does, and the second provides context. It's appropriately sized for a simple help 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 the tool's complexity (simple, no parameters) and lack of annotations or output schema, the description is minimally adequate. It covers the basic purpose and usage but lacks details on behavioral aspects like output format or system requirements. For a help tool, this might be sufficient, but there's room for improvement in transparency.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter information, and it appropriately doesn't mention any. Baseline for 0 parameters is 4, as it avoids unnecessary details.

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: 'Get help and see available commands.' It specifies a verb ('Get') and resource ('help and available commands'), making it understandable. However, it doesn't explicitly differentiate from sibling tools like 'capability' or 'list_capabilities', which might also provide informational outputs, so it doesn't reach a score of 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?

The description provides clear context for usage: 'Start here if you are new to APIClaw.' This gives a specific scenario (new users) when to use this tool. However, it doesn't mention when not to use it or name alternatives (e.g., for experienced users, other tools might be more appropriate), so it falls short of a score of 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 provided, the description carries the full behavioral burden. It discloses an important auth-related behavior: unauthenicated calls return action="agent_auth_required" plus the CLI command. It also explains chain execution semantics (sequential, parallel, conditional, loops, retry/fallback, async). However, it does not describe general success respont format, potential costs or confirmations for paid actions, or side effects beyond 'actually do the job', so behavioral disclosure 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 longer than average, but the complexity of the tool (14 parameters, nested chain schema, multi-step orchestration) justifies it. It front-loads the primary purpose in the first sentence and then organizes the details under clear headings: SINGLE CALL, CHAIN, and chain features. The example is valuable; only minor redundancy with the schema's chain descriptions keeps it from 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?

Given the tool's complexity, no annotations, no output schema, and generic external-API scope, the description covers auth, call modes, and chain semantics well. However, it does not explain the success response shape, how to handle confirm_token for costly actions (despite the schema mentioning it), or how results are returned for single vs. chain calls beyond vague mentions like chainId. An agent would still have meaningful unknowns about return handling.

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 all 14 parameters. The description adds meaningful usage semantics beyond the schema: it prescribes the 'provider + action + params' pattern for single calls, explains the chain array with cross-step references ($stepId.property), and gives a concrete two-step example. This materially helps the agent assemble params correctly, especially for chain execution.

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, high-level purpose: 'Primary execution tool' for actually doing external API work through APIClaw, with explicit examples (web search, scraping, speech, LLM calls, invoices, screenshots, currency, weather). This clearly differentiates it from sibling informational/management tools like discover_apis, check_balance, list_models, and mission_* tools. It also distinguishes its two invocation modes, single call and chain, without 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?

It gives clear context for when to use the tool: whenever actual execution of external API work is needed, and it explains the single-call vs. chain decision. It also provides essential usage conditions, such as requiring a free workspace and the unauthenticated response behavior. However, it does not explicitly name sibling tools to avoid or give when-not-to-use exclusions beyond its role as the 'primary' execution tool.

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

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

Without annotations, the description carries the burden of behavioral disclosure. The word 'Check' and the listed statuses (workspace tier, API status, PAYG status) imply a read-only operation, and 'authenticated' signals the authentication requirement. However, it does not explicitly state that there are no side effects or describe response behavior beyond the listed statuses.

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, well-structured sentence with no fluff. The primary verb and purpose are front-loaded, and the three status items are clearly enumerated.

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-check tool, the description is nearly complete: it names the exact statuses being checked and implies the authentication context. It lacks an explicit note on return format or differentiation from the sibling check_workspace_status, but these are minor gaps 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?

The tool has zero parameters, so the schema fully covers parameter semantics. The baseline of 4 applies because there are no parameters to document, and the description correctly focuses on what the tool checks rather than parameter details.

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 specifies the verb 'Check' and the resource: authenticated workspace tier, Free/Paid API status, and verified PAYG status. It is clear and specific, though it does not explicitly distinguish itself from the sibling tool check_workspace_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?

No guidance is provided on when to use this tool versus alternatives like check_workspace_status. The implied usage is to check billing/status information, but no explicit conditions, exclusions, or alternative routes are described.

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 states the tool checks status, tier, and usage, implying a read-only operation, but does not specify whether authentication is required, if there are rate limits, or what the output format might be. This leaves significant gaps in understanding the tool's 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, efficient sentence that directly states the tool's function without any wasted words. It is front-loaded with the core purpose, making it easy for an agent to quickly understand what the tool does.

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 simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose but lacks details on behavioral aspects like authentication or output format, which could be helpful for an agent to use the tool effectively in 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 tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description does not need to compensate for any parameter gaps, and it appropriately focuses on the tool's purpose without unnecessary parameter details, meeting the baseline for parameterless tools.

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 check workspace status, tier, and usage remaining. It uses specific verbs ('check') and resources ('workspace status, tier, usage remaining'), making the function unambiguous. However, it does not explicitly differentiate from siblings like 'check_balance' or 'get_usage_summary', which prevents a perfect score.

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 alternatives. It does not mention any prerequisites, context for usage, or comparisons to sibling tools such as 'check_balance' or 'get_usage_summary', leaving the agent without explicit direction on tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state what the tool returns, whether it queries a registry, whether results are ranked, or whether there are side effects. The behavior is implied by the name but not made explicit.

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 front-loaded sentences with no filler. The first sentence gives the core action and the second scopes when it applies. The capability list is long but directly useful for matching user intent.

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 and schema together cover purpose and parameters well, but with no output schema and no annotations the agent must infer return shape and follow-up steps like calling get_api_details. The callable_only registry nuance is detailed in the parameter schema but not surfaced in the main description.

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. The description adds a job-to-be-done framing and an expanded list of query intents (web search, scraping, email, SMS, speech, PDFs, etc.), which helps the agent formulate the query parameter beyond the schema examples.

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 identifies the tool as 'Find APIs by job-to-be-done' and provides concrete capability examples such as web search, SMS, PDFs, and browser automation. This distinguishes it from siblings like get_api_details (known API) and call_api (executing an API).

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 states when to use it: when the user asks 'what API can do X?', wants provider recommendations, or needs various external capabilities. It doesn't provide when-not-to-use guidance or name alternatives, but the context is clear enough for routing.

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 behavioral transparency burden. It does well by disclosing that ranking combines keyword relevance with a live providerHealth success-rate signal, and that degrading providers cause templates to slide down automatically. It also states what the response contains, though it does not discuss auth, rate limits, or error 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 three sentences with no filler. The first sentence states the core operation, the second explains the return structure and ranking behavior, and the third gives the usage context. Every sentence contributes distinct, 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?

There is no output schema, so the description compensates by listing the returned fields (slug, version, title, description, paramSchema, match reasons) and explaining the ranking mechanism. It is sufficient for an agent to select and invoke the tool correctly, though it omits an example response or note on edge cases like empty queries.

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 query and max_results are already documented with sensible descriptions. The tool description adds minimal new parameter-level detail beyond reinforcing the natural-language nature of the query, so a baseline score 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 description opens with a specific verb and resource: 'Search mission templates by natural-language query.' It also clarifies that results are ranked and what fields they contain, distinguishing this from list_mission_templates, which presumably returns an unranked list. The naming of the follow-up tool, start_mission, further anchors 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?

The description gives clear context: 'Use this to find the right template by intent before calling start_mission.' This tells the agent when to use it, but it does not explicitly name list_mission_templates as an alternative or state when not to use this tool, so it stops short of full exclusion guidance.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation via 'inspect' and mentions a behavior (response size control with compact=true), but it doesn't explicitly state absence of side effects, authentication needs, or failure handling. The hint about oversized responses is useful but not a thorough disclosure.

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 zero fluff. It front-loads the core purpose, then adds usage context and a practical tip. Every word earns its place.

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

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

For a two-parameter tool with no output schema, the description covers the main job, typical use, and a parameter tip. It does not specify return format or error behavior, but those are likely inferable from the enumerated content and the simple nature of a lookup tool. Minor omissions keep it 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 coverage is 100%, so both parameters are documented in the schema. The description adds a platform-specific note about Claude/Desktop for compact, which is mildly helpful but largely redundant since the schema already explains the parameter's purpose. 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 description states a specific verb ('inspect') and resource ('one provider'), and enumerates the type of information returned (endpoint names, params, pricing, auth, docs). This clearly differentiates it from siblings like discover_apis and call_api.

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 an explicit when-to-use ('Good when the agent needs endpoint names, params, pricing, auth, or docs') and spatial-temporal context ('after discovery'). It also provides a practical tip about compact=true for response size. However, it doesn't explicitly mention when not to use it or name alternative 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 provided, so the description carries the full disclosure burden. It adds useful behavioral context: lightweight by design, intentionally omits API IDs, and returns aggregate counts. It does not touch on auth or error behavior, but for a simple read-style listing tool the stated constraints are meaningful.

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 front-loads the purpose and output; the second delivers the key limitation and the routing directive. Every word contributes to the agent's decision.

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 tool with one optional parameter and no output schema, the description covers what is returned (total + callable counts), what is intentionally excluded (API IDs), and where to go for deeper detail (discover_apis). An agent has enough context 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 100%, with the single boolean parameter fully documented: default, effect, and auto-compact warning. The description doesn't need to add parameter-level detail; the schema already carries it. The 'lightweight' phrasing indirectly aligns with the default behavior but adds no new 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?

States a specific verb ('List'), the resource ('API categories'), and the exact output ('total + callable counts'). It also distinguishes itself from the sibling discover_apis by explicitly noting it does NOT dump every API ID, so an agent can tell them apart without inspecting schemas.

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 names the alternative tool discover_apis and the condition for choosing it: 'Use discover_apis(query, category) to drill into a category.' The description also positions list_categories as the lightweight overview option, making the when-to-use decision 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 provided, the description carries the behavioral disclosure burden. It transparently notes that the tool works without key paste, defaults to a compact execution-ready summary, and only includes source-verified entries when verbose=true. It does not disclose output format details or potential side effects, but for a list/summary tool the key behavioral traits are covered.

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 three tight sentences with no filler. The core purpose is front-loaded, the verbose condition is stated clearly, and the sibling-tool alternative is given without unnecessary detail.

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

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

For a two-optional-parameter list tool with no output schema, the description gives sufficient context to invoke it correctly: what it lists, the default mode, when to enable verbose, and when to use an alternative. It does not specify the exact return fields, but the phrase 'compact execution-ready summary' gives a usable mental model.

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 parameters are already well documented in the schema. The description adds usage context for verbose but no additional semantic detail beyond what the parameter descriptions already provide, so the baseline score 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 description clearly identifies the tool as returning a summary of managed providers callable right now through APIClaw without key paste, which is a specific resource and scope. It also distinguishes the tool from discover_apis by mentioning that discover_apis is for narrow lookups rather than dumping the whole catalog.

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 when to use verbose=true, namely only when source-verified discovery entries are needed. It also directs agents to use discover_apis(query) for narrow lookups instead, providing clear routing guidance among 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 burden of behavioral disclosure. It does disclose ordering and workspace scoping, which are useful behavioral traits, but it does not mention return shape, pagination behavior beyond the limit parameter, or any access 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?

A single front-loaded sentence that states the action, scope, and ordering with no filler. Every word 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 low-complexity, single-optional-parameter tool, the description is nearly complete. It lacks explicit return-value details, but the absence of an output schema and the simple 'list' semantics make this acceptable.

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% because the only parameter, limit, is fully described in the schema with its default and max. The tool description adds no new meaning to that parameter, so the baseline of 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?

The description names a specific verb and resource ('List missions'), scopes it to the current workspace, and specifies ordering ('most recent first'). It is clear, though it does not explicitly differentiate itself from siblings like discover_missions or list_mission_templates.

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 prefer this tool over discover_missions, mission_status, or list_mission_templates. The description implies a current-workspace context but gives no exclusions, prerequisites, or alternative conditions.

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. The phrase 'List the mission templates available to your agent' clearly indicates a read-only, non-destructive operation and scopes the results to the agent's context. There are no hidden side effects hinted at, and none are needed for a simple listing 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?

One concise, front-loaded sentence that conveys both the action and the output scope. Every word carries meaning, with no filler or redundant 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 list tool, the description is largely complete: the agent knows what is listed and what information is returned. The absence of an output schema means the exact response format is not defined, but the description's promise of template names and parameters is sufficient for an agent to call this tool successfully.

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 no parameters and 100% schema description coverage, so the schema fully documents what is accepted. With 0 parameters, the description earns a baseline 4 and doesn't need to compensate for any undocumented 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 ('List') and resource ('mission templates'), and adds that it returns the parameters each template accepts. This clearly identifies the tool's purpose, though it does not explicitly differentiate it from sibling tools like list_missions or discover_missions.

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 tool should be used when an agent needs to know which mission templates and their accepted parameters are available. However, it does not provide explicit guidance on when to use this tool versus alternatives such as list_missions, discover_missions, or start_mission.

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 does add meaningful context by saying 'live' and warning that 'Catalog presence does not prove execution readiness.' However, it does not explicitly state that listing is read-only, mention authentication needs, or disclose rate limits or pagination behavior, which are relevant for a tool with no 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 two tight sentences with no filler. The main action is front-loaded, and the caveat about execution readiness is a valuable second sentence that earns its place without bloating the text.

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

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

This is a low-complexity tool with one optional parameter and no output schema. The description explains what the entries identify and adds an important limitation. It does not detail the response format further, but for a simple catalog list the description covers the essentials an agent needs.

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 single optional provider parameter is already fully documented in the schema. The description does not elaborate on the parameter's behavior, such as exact supported values or filtering semantics, but it is not required to compensate for a 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?

The description uses a specific verb and resource: 'List the live APIClaw model catalog.' It also specifies what entries contain (owner, serving source, gateway endpoint), which clearly distinguishes this from sibling tools like discover_apis or list_categories. The added caveat about execution readiness reinforces what this tool does and does not provide.

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 useful context: it is a catalog listing, not an execution readiness check. However, it does not explicitly name alternatives or state when to prefer this over related tools like discover_apis or get_api_details, leaving the agent to infer the selection logic.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It does clarify the kinds of information returned (status, audit events, cost, final result), but it doesn't address side effects, authentication needs, error behavior, or output shape. The verb 'check' implies read-only, but the description doesn't explicitly confirm 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?

A single sentence that is tight and front-loaded with the action and object list. Every word earns its place; there is no filler or repetition.

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

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

For a one-parameter status tool with no output schema, the description does a good job of indicating what the user will learn by naming the categories returned. It omits edge cases such as what happens when a mission_id does not exist or how cost is computed, but these are minor gaps for a straightforward status check.

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 explains mission_id thoroughly as the id from start_mission. The tool description reinforces that connection but adds no new parameter-level meaning. 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 description states a specific verb ('Check') and a well-defined resource (status, audit events, cost, and final result for a mission). It explicitly ties the tool to missions started via start_mission, which distinguishes it from siblings like list_missions or check_workspace_status. This leaves no doubt about what the tool does.

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 frames when to use it: for a mission that was started via start_mission. This is useful contextual signal. However, it doesn't explicitly name alternatives or state when-not-to-use, so it stopst short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that missions are observable/pollable, that the tool returns a missionId, and that execution path depends on template type and template_version pinning: "Legacy templates run through the hand-coded path; data-driven templates run through the v2 composition runner." It stops short of disclosing side effects, permissions, or idempotency behavior, so it isn't a 5, 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 four sentences and every sentence earns its place: purpose, usage condition, return/polling guidance, and execution-path nuance. It is front-loaded with the most important information and contains 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?

Given the tool's complexity — 4 parameters, nested params object, no output schema, and a large sibling set — the description is mostly complete. It states return value (missionId), the polling route, and how it differs from single API calls. Minor gaps like error handling, cost, or cancellation are not mentioned, but an agent has enough 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 100%, so the baseline is 3. The tool description itself adds little parameter-level meaning beyond the schema — it mentions template_version pinning in the context of execution path, but the schema already explains each parameter clearly. Thus 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 — "Start a mission" — and expands on what a mission is: "a structured, observable orchestration that runs on APIClaw's runtime." It clearly differentiates from a single API call, which is the relevant sibling (call_api), so an agent can immediately tell when this tool is the right 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?

It explicitly states the intended use case: "Use this when the user wants to spin up a multi-step task rather than a single API call." This tells the agent not only when to use start_mission, but also implicitly directs single-call scenarios to a sibling. It additionally points the agent to mission_status for polling the returned missionId, which is actionable guidance.

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