Locus

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

Annotations already declare destructiveHint=true and idempotentHint=true, and the description's 'Cancel' aligns with that destructive behavior. It adds the 'unused' condition, implying cancellation is only valid before execution, but it does not describe side effects or irreversibility beyond what annotations imply.

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 six-word sentence that front-loads the verb and object. There is no filler, and every word contributes meaning.

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

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

For a simple single-parameter tool with an output schema and safety annotations, the description is nearly sufficient. However, it leaves undefined what constitutes an 'executable quote', how 'unused' is determined, and what cancellation entails in practice, so an agent may need to infer these details.

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 fully documents the single approval_token parameter as an 'estimate_cost token' with min/max length constraints, so schema coverage is 100%. The description adds no additional parameter semantics, 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?

States a clear action ('Cancel') on a specific resource ('an unused executable quote'), aligning with the title. The action and object distinguish it from siblings like estimate_cost and execute, though the term 'executable quote' is somewhat domain-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 word 'unused' implies this tool should be used only before a quote has been executed, and the sibling set suggests alternatives like estimate_cost and execute. However, it does not explicitly state when to use or avoid this tool, nor does it name alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that price is returned, which is useful context beyond annotations, but it does not disclose any additional behavioral traits such as pagination via operation_offset or rate limits. It is consistent with the annotations, so 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 a single, tight sentence with no filler. It front-loads the core purpose and the key artifacts returned. Every word earns its place, and it is easy to parse at a glance.

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 that an output schema exists, the description need not explain return structures, and the input schema is fully documented. The combination of description, schema, and annotations is adequate for a read-only retrieval tool. A minor gap is that the description doesn't mention the alternative invocation via operation_query, but this is not critical and is visible in 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 100%, so the baseline is 3. The description does not elaborate on the parameters (slug, operation_query, operation_offset), but the schema already provides adequate descriptions for each. It adds no extra meaning beyond what the schema already states, so a mid-score 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 states the verb 'Get' and the resource: one endpoint's schema, example, output shape, and price. This specific list of returned artifacts distinguishes it from siblings like search_apis (which searches for endpoints) and estimate_cost (which estimates costs). An agent can immediately understand the tool's scope and differentiate it from alternatives.

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

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

The description provides no guidance on when to use this tool versus siblings such as search_apis or estimate_cost. It does not mention needing a slug from a prior search, nor does it state exclusions or alternatives. Usage context is only implicit in the phrase 'one endpoint', leaving the routing decision to inference.

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

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

The description adds the key behavior of quoting with an optional hard cap and notes that inputs go in the body. However, given readOnlyHint is false, it does not disclose whether creating a quote has side effects or how it relates to execute.

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 front-loaded sentence, no filler. 'Quote a costly or sensitive call' captures purpose first, followed by the hard-cap option and body-input instruction.

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 9-parameter tool with no required params, this description is too thin. It omits the crucial pre-execution relationship with execute, side effects, and endpoint selection expectations; the rich schema and output schema do not compensate for the missing usage 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 coverage is 100% and every parameter has a description, so the schema already handles parameter semantics. The description's 'pass inputs in body' adds a mild usage hint, but it does not provide substantive meaning beyond the structured fields.

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 'Quote' and defines the resource as 'a costly or sensitive call', which makes the primary purpose clear. It also mentions the optional hard cap, but it does not explicitly contrast with siblings like execute or cancel_cost_approval.

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

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

No when-to-use or when-not-to-use guidance is provided. The phrase 'costly or sensitive call' implies a condition, but there is no explicit instruction to invoke this before execute or any mention of alternatives.

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

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

Annotations already disclose destructive=true, non-idempotent, open-world behavior, and the description adds genuinely useful context beyond them: 'charges credits' (financial side effect) and 'enabled endpoint' (access prerequisite). No contradiction with annotations; the description complements rather than duplicates them.

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

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

Nine words across two clauses, with the action ('Call an enabled endpoint') front-loaded and the cost warning attached. Every word earns its place; nothing is redundant or extraneous.

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

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

The output schema and rich annotations cover returns and safety, and the schema documents the approval_token/idempotency_key linkage to estimate_cost. However, the minimal description leaves the full execution workflow (estimate → approve → execute → retrieve) implicit, which is a notable gap for the central invocation tool in this ecosystem.

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 all six parameters documented in the input schema, so the baseline of 3 applies. The description itself adds no parameter-level meaning, but it does not need to since the schema fully covers param semantics.

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

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

The description states a specific verb and resource ('Call an enabled endpoint') plus provenance ('found via search_apis') and a distinguishing behavior ('charges credits'). This cleanly separates it from siblings like search_apis (discovery), describe_api (description), and estimate_cost (pricing), so an agent can route correctly without opening 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?

The phrase 'found via search_apis' implies the correct workflow (discover first, then execute) and 'charges credits' hints that cost approval may be needed, but the description never explicitly names alternatives or exclusion conditions. It does not tell the agent when to prefer estimate_cost for pre-flight or get_call_result for retrieving async results, leaving routing to inference.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about the pooled account vs end-user selection, which is beyond the schema. However, it doesn't detail response structure or potential errors, which could be important.

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 short sentences, focused and efficient. The key information (credits and auth-dependent account) is front-loaded. Minor ambiguity in 'credits' vs 'balance' but acceptable.

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

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

Given the simplicity of the tool (one optional param, no nested objects, has output schema), the description is nearly complete. It explains the auth nuance, and the output schema likely covers return values. It doesn't mention potential error cases or rate limits, but those are not critical 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?

Schema description coverage is 100%, and the parameter description is self-explanatory. The tool description does not add significant extra semantics beyond the schema, but this is acceptable because the schema already covers 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 clearly states the tool's purpose: getting credits/balance. It mentions the optional external_user_id for secret-key auth, which adds specificity. However, it doesn't explicitly differentiate from sibling tools like estimate_cost or describe_api, but the verb+resource is clear enough.

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

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

The description implies usage: it says secret keys may select an end user or pooled account, hinting at auth context. It does not explicitly state when to use this vs alternatives, but given the simple purpose, that is acceptable. The parameter description in the schema further clarifies the usage condition.

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 non-destructive behavior completion. The description adds the 'bounded' chunk semantics and receipt-keyed access, but it does not mention pagination behavior, ordering, or error handling for unknown receipt IDs.

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

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

The description is a single sentence with an active verb front-loadedcars. 'Read', 'bounded', 'prior-result', and 'receipt ID' each carry real semantic weight with no filler or 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?

Given a fully documented schemaasi and an output schema, the description covers the essential scope of the tool. The only gap is lack of explicit sibling-tool routing and any note about chunking with offset/max_characters to a human level.

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 description's 'bounded' and 'receipt ID' language loosely mirrors max_characters and api_call_id, but it contributes no new parameter-level detail 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 a specific action ('Read'), a specific resource ('bounded prior-result chunk'), and the required key ('receipt ID'). This clearly distinguishes get_call_result from siblings like execute, search_apis, or describe_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 phrase 'prior-result' plus 'receipt ID' gives a clear contextual signal that this tool is for reading output from an earlier call. It does not explicitly contrast with sibling tools or state when not to use it, so it misses the top score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond 'Fetch,' such as pagination via cursor, max_characters chunking, or version/section selection behavior. Given that these behaviors are meaningful and undisclosed, the description falls short.

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

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

The description is a single, front-loaded sentence with no wasted words. 'Fetch Locus guides' identifies the action and object immediately, and the condition adds necessary usage context.

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

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

The tool has six optional parameters and an output schema, but the description gives no high-level orientation (e.g., how to list vs. fetch a specific guide, pagination behavior). The schema covers individual parameters, so the description is minimally adequate, but it leaves the agent to infer the overall usage pattern from schema fields alone.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself provides no parameter-level detail, but the schema already documents id, task, cursor, section, version, and max_characters, so the description does not need to compensate.

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

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

The description states a specific verb and resource ('Fetch Locus guides') and provides a scoping condition ('when native skills are unavailable'). It is clear about what the tool does, though it does not explicitly name sibling tools, leaving the differentiation to the 'native skills' phrase.

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 an explicit when-to-use condition: 'when native skills are unavailable.' This is a clear contextual trigger, but it does not mention any sibling tools by name or provide explicit when-not-to-use guidance beyond the implied condition.

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 provide readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is well covered. The description reinforces that no tools are enabled, but adds no further behavioral detail such as authentication needs or pagination 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?

A single front-loaded sentence with no filler. It communicates the core purpose and the important non-side-effect boundary in minimal space.

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 listing tool with fully documented parameters, an output schema, and strong annotations, the description covers the essential purpose and limitation. It could be slightly more complete by naming sibling tools for enabling access, but nothing critical is missing for correct invocation.

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

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

Schema coverage is 100%, so all four parameters already carry clear descriptions, defaults, and constraints. The description adds only mild context around 'categories and packs' and does not substantially improve parameter understanding.

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

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

Description uses a specific verb 'Browse' and a clear resource ('executable categories and packs'). The added 'does not enable tools' explicitly separates it from activation tools like request_tool_access.

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 marks this as a read-only browsing operation and explicitly warns it will not enable tools, preventing misuse. It stops short of naming a specific alternative for enabling access, so it is not a full 5.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false, and the description complements this by noting the one-time context-cost acknowledgement requirement. It also implies that pinning affects model context on every connection, which is valuable behavioral information beyond what annotations provide. 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?

Two sentences with no filler. It front-loads the core function and puts the critical caveat second. Extremely 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?

Given the tool's moderate complexity, a clear schema with good coverage, and an output schema, the description suffices. It covers the action, the key constraint (first pin acknowledgement), and context-cost impact. It lacks detail on consequences of unpinning, but that is minor.

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 schema already documents all parameters. The description adds minimal extra meaning, but the overall message is clear. Since coverage is high, 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 clearly states the tool adds or removes an enabled endpoint as a typed tool on workspace MCP connections. It uses precise verbs (add/remove) and specifies the resource (endpoint, MCP connections), distinguishing it from siblings like list_tool_groups or request_tool_access.

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 is clear about the primary action and mentions a specific prerequisite for the first pin (context-cost acknowledgement). It doesn't explicitly state when NOT to use this tool or suggest alternatives, but it clearly implies it is for managing pins, which is sufficient for most usage scenarios.

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 only say readOnly=false and non-idempotent, so the description carries the behavioral burden. It usefully discloses that the result is a short-lived link requiring human approval, which signals side effects and workflow; it does not mention more granular effects, but the added context is 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?

The description is one sentence with no filler, front-loading the action and object before scoping to disabled catalog endpoints. 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?

With a single fully-documented parameter and an output schema present, the description is mostly complete: it names the workflow, object, and scope. It could be slightly stronger by noting that usage is only appropriate when the endpoint is disabled or by routing to alternatives, but this is a minor gap at low 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?

The input schema fully describes the only parameter, slug, including its pattern and the instruction to use the exact provider/endpoint slug from search. The description does not add parameter-level detail, but schema coverage is 100%, 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 description uses a specific verb ('Create') with a precise resource ('short-lived human approval link') scoped to 'one disabled catalog endpoint.' This clearly distinguishes it from sibling tools like execute or pin_endpoint, which operate on endpoints differently.

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 'for one disabled catalog endpoint' implies the tool is for requesting access when an endpoint is disabled, but it never explicitly states when to choose it over alternatives or what prerequisites apply. No alternatives/exclusions are named.

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 operation as read-only and idempotent, so the description adds value by disclosing the default result scope ('enabled catalog APIs by default') and that disabled APIs can be included. This is useful behavioral context beyond the structured hints.

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

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

The description is a single tightly worded sentence that puts the main action first and communicates default behavior plus filtering capability without any 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?

With a rich input schema, output schema, and safety annotations, the description is mostly sufficient. Its only notable gap is the absence of any guidance on when to use sibling tools, but an agent can still correctly invoke this tool from the description alone.

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

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

Schema description coverage is 100%, and every parameter already has a clear meaning in the schema. The description reinforces the enabled-API default but does not add new semantic information about the parameters beyond what the schema provides.

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

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

The description states a specific verb and resource ('Find enabled catalog APIs') and adds concrete scope: results include prices and access state and can be filtered to disabled APIs. This clearly distinguishes search_apis from siblings like describe_api or execute.

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 conveys the core use case—searching catalog APIs with an enabled/disabled filter—but does not explicitly say when to prefer it over alternatives such as describe_api or pin_endpoint. The usage context is clear enough to infer, but no alternatives or exclusions are named.

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