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

Annotations declare readOnlyHint=true, and the description's 'List' verb aligns with that safe-read behavior. The description adds the meaningful restriction that only requestable packages are returned. It does not cover pagination or output ordering, but the presence of an output schema reduces the need for that detail.

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

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

The description is a single, focused sentence with no filler. It front-loads the action and resource, then adds the distinguishing scope.

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 no-parameter, read-only listing tool with an output schema, the description is entirely sufficient. An agent understands exactly what to expect and when to use this tool.

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

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

There are zero parameters and the schema description coverage is 100%, so there are no parameters requiring documentation. The description still clarifies what the catalog contains, which is useful context beyond the empty schema.

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

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

The description clearly identifies the action (List) and resource (business access packages), and narrows the scope to packages an employee may request, distinguishing it from the admin-oriented gateway_admin_access_package_catalog sibling. This precision lets an agent select it 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 'that an employee may request' establishes the intended context: this is for employee-requestable packages rather than admin-managed catalogs. It does not explicitly name alternatives or exclusions, but the context is clear enough for a simple list-only 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?

Annotations already declare readOnlyHint=true, so the description doesn't need to restate safety. The description adds the specific data returned (identity, scopes, access packages, recent requests), which is useful. However, it doesn't disclose any additional behavioral traits like whether 'recent access requests' includes pending/approved/denied, or whether the output is paginated. With annotations covering the read-only nature, a 3 is appropriate.

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

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

One sentence, front-loaded with the verb and resource, and lists the key output categories. No wasted words.

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

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

For a zero-parameter read-only tool with an output schema, the description is complete enough. It tells the agent what data it will get. It could mention that this is the caller's own profile (vs. admin views), but the phrase 'current authenticated identity' already implies that. The output schema likely covers return details, so nothing critical is missing.

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

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

The tool has 0 parameters, so the schema is trivially complete (100% coverage). The description adds meaning by explaining what the tool returns, which is the only semantic content needed. Baseline 4 for 0-param tools 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's purpose: showing the current authenticated identity, effective scopes, access packages, and recent access requests. It uses a specific verb ('Show') and resource ('current authenticated identity...'), which distinguishes it from sibling tools like gateway_access_request_list or gateway_admin_list_access. However, it doesn't explicitly name a sibling to differentiate from, so it's clear but not maximally distinct.

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: call this to see your own access profile. It doesn't explicitly state when to use it versus alternatives like gateway_access_request_list or gateway_admin_explain_access. The context is clear enough for a self-profile tool, but no exclusions or alternative routing are provided.

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

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

Annotations provide no safety hints (no readOnlyHint or destructiveHint), so the description must carry the behavioral burden. It only states 'cancel' without disclosing side effects, reversibility, or impact on approval workflows. The 'pending' constraint is useful but insufficient.

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. It efficiently conveys the core purpose without verbosity.

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 mutation nature of the tool and zero annotation coverage, the description lacks essential context about preconditions, side effects, error scenarios, and the meaning of the 'reason' parameter. The output schema exists but does not compensate for the missing behavioral and semantic 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?

Schema description coverage is 0%, so the description must explain both parameters. It implicitly references request_id but never mentions the optional 'reason' parameter, leaving its purpose and usage entirely unclear.

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 action (cancel), the resource (pending access request), and a key constraint (owned by the current user). It effectively distinguishes from sibling tools like gateway_access_request_create and gateway_admin_access_request_decide, though it could be more explicit about the ownership restriction.

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 that this tool is for the user's own requests, which hints at when to use it versus admin tools, but it does not explicitly name alternatives or state when not to use it. The ownership constraint is present but not elaborated.

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 carry only a title, so the description bears the full burden. It adds one valuable behavioral disclosure — 'This never grants access automatically' — preventing the costly assumption that the request results in access. But it omits other relevant behavior, such as the request entering an approval workflow or the semantics of idempotency_key and ttl_days.

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 zero filler; the core action is front-loaded and the critical caveat ('never grants access automatically') follows immediately. Every word earns its place.

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

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

The output schema covers return values, but the description is still incomplete for a workflow-creating tool with four undocumented parameters. It does not place the tool in its lifecycle context: what happens after submission, whether later cancellation is needed, or how this request relates to the approval/decide sibling tools. An agent can select the tool but cannot invoke it with full confidence or set correct user expectations.

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

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

Schema description coverage is 0%, so the description must compensate, but it only indirectly glosses package_key ('business access package'). The required parameters (package_key, reason) get no explicit explanation, and ttl_days and idempotency_key are entirely unaddressed, leaving important invocation details 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?

The description states a specific verb ('Request'), resource ('versioned business access package'), and actor ('current user'), clearly differentiating it from siblings like gateway_admin_grant_access_package (granting) and gateway_admin_access_request_decide (deciding on requests). An agent can tell what this does at a glance.

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 scope ('for the current user') and gives a when-not signal ('never grants access automatically'), which tells the agent this tool will not deliver immediate access. However, it never names alternative tools (e.g., gateway_admin_grant_access_package) or states explicit conditions for choosing them instead.

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, so the read-only nature is covered. The description adds no additional behavioral context—such as default limit behavior, status filtering semantics, pagination, or ordering—beyond what the annotation provides. It contributes minimal extra transparency.

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

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

The description is a single, concise sentence that is front-loaded with the core purpose. It is efficient and readable, but it is perhaps too brief, omitting necessary parameter and usage details. As a result, conciseness is good but at the expense of completeness.

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 has two parameters with no schema descriptions, an output schema exists but its structure is unknown, and there are closely related sibling tools, the description is insufficient. It does not explain parameter usage, expected response format, or how it differs from similar tools, leaving an agent under-informed.

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

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

With schema description coverage at 0%, the description must explain the parameters. It does not mention 'limit' or 'status' at all, leaving their meanings and defaults undocumented. This is a significant gap for a tool with two optional 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 uses a specific verb ('List') and resource ('access requests') with a clear scope ('created by the current user'), which distinguishes it from the admin-level list (gateway_admin_access_request_list). However, it does not explicitly name any sibling tool, so differentiation is implicit rather than stated.

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

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

No guidance is provided on when to use this tool versus alternatives like gateway_admin_access_request_list or gateway_access_request_create. The description only states what it does, not the context or exclusions.

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, and the description's 'List' verb is consistent with that. The description adds the 'versioned' qualifier and the access:read requirement, providing some behavioral context beyond annotations, though it does not explain versioning semantics or output 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?

One short, front-loaded sentence with no filler. The core action and the permission requirement are both included efficiently.

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

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

The tool is simple (zero params, output schema exists, read-only annotation present), so the short description is mostly sufficient for invoking it. However, it lacks any guidance that would help an agent distinguish this catalog tool from similarly named access-package tools, leaving a meaningful context gap.

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 and schema description coverage is 100%, so the schema fully handles parameter documentation. Per the calibration baseline for zero-parameter tools, the description does not need to add parameter detail.

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

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

The description states a clear verb and resource: 'List versioned business access packages.' It clearly identifies the tool's function with the 'versioned' qualifier, which hints at a distinction from siblings like gateway_admin_list_access_packages, but it does not explicitly differentiate itself.

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

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

The description only states a permission prerequisite ('Requires access:read') and gives no guidance on when to choose this tool over the many similar access-package list/catalog siblings such as gateway_admin_list_access_packages or gateway_access_package_catalog. No exclusions or alternative conditions are provided.

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

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

The description discloses a critical behavioral trait: 'defaults to dry-run.' This is valuable because the schema's dry_run default is true, and the description confirms that the tool will not execute the decision unless dry_run is explicitly set to false. It also states the permission requirement. It does not describe the output shape, but an output schema exists, so that burden is reduced.

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. It front-loads the core action, then adds the permission requirement and the dry-run default. 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 single-decision tool with an output schema, the description covers the essential behavioral context: what it does, what permission is needed, and the dry-run default. It does not explain the relationship to gateway_approval_decide or what happens when dry_run is false, but the output schema and the clear action verb cover most of what 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 0%, so the description must compensate. It names the three required parameters implicitly: request_id (the request being decided), decision (approve or reject), and reason (why). However, it does not explain valid values for 'decision' (e.g., 'approve' vs 'reject') or whether 'reason' is free-form or constrained. The dry_run parameter is explained by the description's 'defaults to dry-run' note. This is adequate but not rich.

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 ('Approve or reject') and a specific resource ('one pending access request'), which clearly distinguishes it from sibling tools like gateway_admin_access_request_list (listing) and gateway_approval_decide (generic approval decisions). The phrase 'one pending access request' also signals it operates on a single item, not a batch.

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

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

The description implies when to use it: when deciding a pending access request. It also names a prerequisite ('Requires access:admin'), which helps an agent know whether it is permitted to call it. However, it does not explicitly contrast with gateway_approval_decide or gateway_admin_access_request_list, so an agent might need to infer the boundary between access-request decisions and general approval decisions.

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, so the read-only nature is covered. The description adds the auth requirement 'Requires access:read,' which is useful context not present in annotations. However, it does not disclose other behavioral aspects like pagination, filtering semantics, or default status, leaving the description thin beyond what annotations provide.

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

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

The description is very concise (two sentences) and front-loaded with the main purpose. However, it is so sparse that it omits crucial contextual information, making it under-specified rather than appropriately concise. It earns a middling score for being brief but at the cost of usefulness.

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

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

Given the tool's complexity (4 filter parameters) and the existence of an output schema, the description should still explain the scope (admin vs. user-level), the filtering behavior, and the meaning of parameters. None of this is provided. The description is incomplete for an admin list tool, especially compared to sibling tools that likely have richer descriptions.

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 explanation of any of the four parameters (limit, status, package_key, requester_subject). The description does not compensate for the lack of schema documentation, leaving parameter semantics entirely unexplained.

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

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

The description states a clear verb and resource: 'List employee access requests.' This is specific and unambiguous. However, it does not distinguish from the sibling tool gateway_access_request_list (non-admin), so an agent might not know which to choose without further investigation.

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

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

There is no guidance on when to use this tool versus alternatives like gateway_access_request_list or other admin tools. The only hint is the 'admin' prefix in the tool name, but the description does not explicitly state the difference or mention any prerequisites beyond the auth requirement.

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, so the description correctly avoids restating that. It adds valuable context by noting the results are 'redacted' and that telemetry:read is required, which an agent needs to know before invocation. No contradiction with annotations exists.

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 front-loads the core action and resource, then adds the permission requirement. Every word earns its place, 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 the tool has 10 optional filter parameters, no parameter descriptions, and no usage hints, the description is not complete enough for an agent to query effectively. The output schema and readOnly annotation help, but they do not compensate for the complete absence of parameter semantics and alternative-tool routing.

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

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

Schema description coverage is 0%, so the description must compensate for the 10 undocumented parameters, but it does not mention any of them. While parameter names like days and limit are somewhat self-explanatory, fields such as event, status, system, decision, and tool_name have no allowed-value or formatting guidance.

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

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

The description states a specific verb ('Search') and a clear resource ('redacted GatewayMCP audit metadata'). It also distinguishes this tool from the sibling gateway_admin_audit_summary by emphasizing search over summary, and the 'redacted' qualifier adds precision.

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 about when to use this tool versus alternatives like gateway_admin_audit_summary or gateway_call_tool_sanitized. The only context provided is the telemetry:read permission requirement, which is a prerequisite, not a usage decision guide.

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 include readOnlyHint=true, indicating a safe read operation. The description adds the required telemetry:read scope and the grouping dimensions, which are behavioral details not captured by the annotation. This goes beyond what the structured data provides, though it does not describe output format or potential limitations.

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 conveys the action, resource, grouping dimensions, and a permission requirement. There is zero wasted text, and it reads efficiently.

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 (covering return values) and annotations cover the read-only nature, the description is largely complete. It states what the tool does and the required permission. It could optionally mention the default time window (days default 7) or that all parameters are optional, but these are available in the schema defaults. The description is sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0% – no property has a description. The description mentions 'system' as a grouping dimension, but it does not explain the meaning of 'days', 'limit', or 'actor_subject', nor how they affect the summary. Since the schema provides no semantics and the description only partially covers them, the tool fails to adequately compensate for the lack of parameter documentation.

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

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

The description states a specific verb ('Summarize') and resource ('audit events') with explicit grouping dimensions (event, tool, system, decision, status). This clearly distinguishes it from sibling tools like gateway_admin_audit_search (which likely returns detailed events) and gateway_telemetry_usage_summary (which focuses on telemetry usage). The purpose is unambiguous.

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

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

The description provides no explicit when-to-use guidance or comparison to alternatives. The permission note ('Requires telemetry:read') is about authorization, not usage context. Usage is implied by the name and the summary action, but the tool does not explicitly say 'use this for summaries, not raw logs' or mention any sibling 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?

The annotations already declare readOnlyHint=true, and the description reinforces this by saying 'Explain' rather than mutate. It adds a useful behavioral clue beyond annotations by specifying the required permission, 'Requires access:read,' which helps the agent predict authorization failures.

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?

Both sentences earn their place: the first states the core function, the second states the required permission. It is short, front-loaded, and free of repetitive 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 six parameters, 0% schema coverage, and no output schema text beyond the schema itself, the description is too thin to ensure correct invocation. It doesn't explain how a subject is identified, how groups_json relates to subject_key, or what action/resource_type mean; the output schema exists, but input-side guidance is incomplete.

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

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

Schema description coverage is 0% and the description does not compensate: none of the six parameters (system, action, resource, groups_json, subject_key, resource_type) are explained. The phrase 'user/group subject' hints at subject semantics, but no parameter mapping or format guidance is given.

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 ('Explain') and target ('whether a user/group subject can access one MCP resource'), making the tool's core purpose understandable. It distinguishes itself from the many admin/access siblings only by mentioning 'one MCP resource, but it never explicitly names an alternative, so it doesn't fully earn a 5.

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

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

No when-to-use guidance is provided: it doesn't say when to prefer this over gateway_admin_list_access, gateway_admin_grant_resource, or gateway_access_profile. The only extra info, 'Requires access:read,' is a prerequisite, not a usage decision.

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

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

The description discloses two behaviorally relevant traits beyond the annotations: the operation is atomic and requires access:admin. It does not mention side effects, reversibility, or that dry_run defaults to true, which is a notable omission for an admin mutation tool.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the admin permission requirement is provided as useful supplementary information.

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

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

Despite having an output schema Alert, the tool has six parameters, four required, and zero schema descriptions. A complete description would clarify required parameter semanticsroutes, especially subject_type values, the dry_run default behavior, and how package grants compare to scope/resource grants. Current description is too sparse for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the six undocumented parameters. It clarifies that package_key refers to a business access packageaging package, but it does not explain subject_type, subject_key, reason, dry_run, or ttl_days. This leaves agents unable to determine valid parameter values.

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 ('Assign'), a clear resource ('complete business access package'), and a distinctive trait ('atomically'). This differentiates it from sibling tools like gateway_admin_grant_scope and gateway_admin_grant_resource, which operate on narrower access units.

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 'complete business access package' implies this is for package-level grants rather than scopes or resources, so usage context is indirectly conveyed. However, the description does not explicitly state when to use this tool versus alternatives like gateway_admin_grant_scope, gateway_admin_grant_resource, or gateway_admin_revoke_access_package.

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 carry only a title, so the description must disclose behavior on its own. It adds the admin permission requirement and notes dry_run defaults to true, but it never explains that dry_run prevents actual changes, what happens when dry_run is false, or that the operation is a persistent mutation. This is minimal disclosure for an admin mutation.

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

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

The description is one tight sentence with no filler; the purpose is front-loaded and the permission/default caveats are packed efficiently. Every word contributes.

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 complex 11-parameter admin mutation with no safety annotations, yet the entire description is a single sentence. It lacks parameter semantics, side-effect disclosure, and routing guidance; the output schema does not compensate for these 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% with 11 parameters, yet the description only mentions resource_pattern and dry_run. subject_type, subject_key, system, effect, actions_json, priority, ttl_days, resource_type, and reason are left completely undefined, so the agent cannot correctly construct the required arguments.

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-resource pair ('Grant or deny one MCP resource pattern') and the resource type 'resource pattern' clearly differentiates it from sibling tools like grant_scope and grant_access_package. Even though it doesn't name a sibling, the scope is unambiguous.

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

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

No guidance is given about when to choose this tool over alternatives such as revoke_resource, grant_scope, or grant_access_package. 'Requires access:admin' is a permission prerequisite, not a usage criterion, and no exclusions or preferred contexts are stated.

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

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

The description discloses the critical behavioral trait that dry_run defaults to true, which is essential safety information for an agent invoking a mutation tool. It also states the required admin permission, which is behavioral context beyond what annotations provide. The annotations only include a title, so the description carries the full burden and does well by surfacing the dry-run safety default and the Postgres implementation detail.

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

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

The description is a single sentence that packs the verb, resource, implementation detail, permission requirement, and safety default into 14 words. Every element earns its place, and the most critical safety information (dry_run default) is front-loaded at the end of the sentence where it's still immediately visible.

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

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

The description covers the essential safety and permission context, and an output schema exists which reduces the need to explain return values. However, with 7 parameters and 0% schema description coverage, the description doesn't fully explain the parameter semantics (especially subject_type, subject_key, ttl_days, and reason). The tool is moderately complex as an admin mutation with multiple optional parameters, so more parameter guidance would be needed for full completeness.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions 'Grant or deny' which maps to the 'effect' parameter (allow/deny), and 'scope' maps to scope_name, but it doesn't explain subject_type, subject_key, ttl_days, reason, or dry_run semantics beyond the default. With 7 parameters and zero schema descriptions, the description only partially compensates for the gap.

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

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

The description states a specific verb ('Grant or deny') and resource ('a Gateway scope through Postgres'), which clearly identifies the operation. It distinguishes from siblings like gateway_admin_revoke_scope by covering both grant and deny in one tool, though it doesn't explicitly name the sibling. The 'through Postgres' detail adds implementation context that helps differentiate from other admin tools.

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

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

The description implies usage context by mentioning the required 'access:admin' permission and the dry_run default, which signals this is an admin-only operation with safety defaults. However, it doesn't explicitly state when to use this tool versus alternatives like gateway_admin_revoke_scope or gateway_admin_grant_resource, nor does it explain when a deny effect would be preferred over using the revoke 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?

Annotations already provide readOnlyHint=true, so the description correctly does not repeat that. It adds valuable context: the tool is 'DB-backed' (indicating the data source) and requires 'access:read' permission, which is a specific behavioral constraint not covered by annotations. No contradictions with 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 a single, efficient sentence that front-loads the core purpose ('List DB-backed GatewayMCP scope and resource grants') and then states the permission requirement. There is no fluff or redundancy, and 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?

Given the tool has an output schema (so return format is defined elsewhere) and annotations cover read-only behavior, the description is mostly complete for a simple list operation. However, the lack of parameter explanations and the absence of any mention of filtering or pagination (e.g., how limit works) leaves a gap for effective invocation. It is adequate but not thorough.

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 explanation of the five parameters (limit, system, subject_key, subject_type, include_revoked). Since the schema lacks descriptions and the description does not compensate, agents are left guessing about parameter semantics. The description should have at least hinted at the filter semantics (e.g., that subject_key/type filter grants).

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 a precise resource ('DB-backed GatewayMCP scope and resource grants'), which clearly distinguishes it from sibling tools like gateway_admin_list_access_packages (which lists access packages) and gateway_admin_explain_access (which explains access). It is unambiguous and immediately identifies the tool's function.

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

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

The description gives a clear context ('List grants') and mentions the permission requirement ('Requires access:read'), which implies it should be used when you need to view grants and have that permission. However, it does not explicitly state when to prefer this over alternatives (e.g., gateway_admin_list_access_packages, gateway_admin_explain_access) or mention exclusions. The usage is implied but not fully elaborated.

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, and the description adds the specific authorization requirement 'Requires access:read,' which is useful operational context beyond the annotation. It does not mention default filtering behavior such as include_revoked defaulting to false, but the read-only safety profile is adequately 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 compact and front-loaded, with no filler; both sentences add information. It is not bloated, though the terse style contributes to missing 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 four optional parameters with no schema descriptions, and the description does not explain their meaning or default behavior. An agent cannot tell what subject_key/subject_type filter, what include_revoked does, or when this listing differs from sibling access tools. The presence of an output schema helps with return values, but input-side guidance is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters, but it names none of them. subject_key, subject_type, include_revoked, and limit are left entirely to the schema, whose property titles give only minimal hints. This is a significant gap for an agent deciding what to pass.

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 ('List') and resource ('assigned access packages'), clearly identifying this as a read-only listing operation. The word 'assigned' helps separate it from package-catalog siblings, though it does not explicitly distinguish it from gateway_admin_list_access or clarify the subject scope.

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 the many sibling admin/access tools, such as gateway_admin_list_access or gateway_admin_access_package_catalog. The only added context is the permission requirement 'access:read', which is a precondition rather than a usage rule. There are no exclusions 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 beyond the title, the description carries the full behavioral burden. It discloses the required permission and the scoping of grants, which is useful. However, it does not mention the dry_run parameter or any side effects such as reversibility, leaving significant behavioral context undocumented.

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 states the action and permission with no wasted words. It is concise and to the point, though it lacks a structured breakdown of parameters or effects.

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

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

The description covers the core purpose and permission, but omits the dry_run parameter's function and any note about reversibility or side effects. Given the output schema exists, return values are covered, but the missing parameter explanation leaves the agent under-informed for correct invocation.

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

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

Schema description coverage is 0%, and the description does not mention either parameter (bundle_id or dry_run). The agent is left to infer from parameter names alone. The description fails to compensate for the schema's lack of documentation, especially the dry_run default behavior, which is critical for safe usage.

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 action (revoke) and the resource (a package), and specifies the scope (only grants created by it). This distinguishes it from sibling tools like revoke_scope or revoke_resource, which target different resource types.

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 for revoking access packages, and it mentions the required permission (access:admin). However, it does not explicitly differentiate when to use this over sibling revoke tools (e.g., revoke_scope, revoke_resource), nor does it state when not to use it.

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

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

Annotations only include a title, so the description must carry full behavioral disclosure. It mentions the destructive action and the dry_run default, which is useful, but it does not explain side effects, reversibility, or what happens on success or failure. For a mutation tool with no annotation hints, this is a moderate disclosure gap.

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

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

The description is two sentences, front-loaded with the core action and permission, and contains no filler. It is appropriately concise for the information it provides.

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 has six parameters with zero schema descriptions and an output schema, the description is highly incomplete. It does not explain how to specify a grant (by ID or subject/pattern), the meaning of each parameter, or the nature of the output. The dry_run note is helpful but far from sufficient for correct invocation.

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

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

Schema description coverage is 0% and the description provides no explanation of any parameters beyond dry_run's default. Six parameters (system, grant_id, subject_key, subject_type, resource_pattern) are entirely unexplained, making it impossible to correctly identify which parameters are required to revoke a specific grant. The description does not compensate at all.

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 'Revoke' and the resource type 'DB-backed MCP resource grants', distinguishing it from sibling tools like revoke_access_package and revoke_scope. The specificity of 'DB-backed' further clarifies the domain.

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 for resource grants and mentions the permission requirement 'Requires access:admin', but it does not explicitly state when to use this tool versus other revoke variants. It lacks an explicit 'when not to use' or alternative routing, leaving some inference to the agent.

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

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

Annotations provide only a title and no readOnly/destructive hints, so the description carries the full burden of behavioral disclosure. It states 'Revoke' which implies a destructive action, but does not explain side effects, reversibility, or consequences of a non-dry-run call. The dry_run default is mentioned, but its significance and what happens when set to false are not clarified.

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

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

The description is very short and front-loads the core action, but it is under-specified. It does not waste words, yet it omits critical parameter context and usage nuance. It is concise but not appropriately sized for the tool's complexity.

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

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

With five parameters (none required), no schema descriptions, and minimal annotations, the description is far from complete. It does not explain how to identify a grant (which combination of parameters), what the output schema contains, or the implications of dry_run. A mutation tool with this complexity requires much more context for correct invocation.

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

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

Schema description coverage is 0%, and the description only mentions dry_run's default. It does not explain grant_id, scope_name, subject_key, or subject_type, leaving an agent without any semantic guidance for four of five parameters. The description adds almost no value beyond what the schema's field names (which are also sparse) imply.

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: 'Revoke DB-backed Gateway scope grants.' This clearly distinguishes it from sibling tools like gateway_admin_revoke_resource and gateway_admin_revoke_access_package, which target different entities. The scope is precise and the action is unambiguous.

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

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

The description does not provide guidance on when to use this tool versus alternatives like grant_scope or revoke_resource. It only mentions a prerequisite (access:admin) but offers no context about selection criteria, when to avoid, or relationship to other revoke tools. An agent would have to infer usage from the name alone.

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

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

With no behavioral annotations beyond a title, this description provides few behavioral details. It verifies the write permission and that the tool adds content, but it does not explain if the comment is append-only, whether it changes the approval state, or what side effects `decision_payload_json` may cause.

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 short, well-structured two-sentence definition. The primary action is front-loaded and the permission requirement is useful rather than padding.

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 three-parameter tool with no schema descriptions and thin annotations, this description is not complete enough. The absent guidance on `decision_payload_json` and the interaction with the approval workflow prevents an agent from fully understanding the tool's effect, even though an output schema exists.

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

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

Schema description coverage is 0%, so the description needed to compensate by explaining parameters; it does not. `approval_id` and `comment` are inferable from the tool name and description, but `decision_payload_json` remains unexplained, leaving a meaningful semantic 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 names the verb 'add' and the resource 'approval', and clarifies the content as a clarification or comment. This is clear enough to distinguish the tool from finalization actions like gateway_approval_decide, though it does not explicitly call out that alternative.

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 only usage guidance is the authorization prerequisite 'requires approvals:write'. The description does not state when to choose this tool over gateway_approval_decide, gateway_approval_create, or other approval-related tools, nor does it give any exclusions or limitations.

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 provide a title, so the description carries the behavioral burden. It does disclose an authorization requirement ('Requires approvals:write') and implies a side-effecting creation, but it does not describe approval workflow implications, four-eyes behavior, or what state the request enters.

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 two sentences are front-loaded and contain no filler; purpose and permission are stated efficiently. However, at only about 16 words for an 11-parameter tool, the text is arguably too sparse to be well-sized for its complexity, though what is present is well structured.

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

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

The output schema may cover return values, but the input side is under-described: approval_type has no allowed values, subject semantics are absent, and optional fields like required_role, four_eyes, and expires_in_days are unexplained. The auth hint and workflow purpose save it from being completely vacuous, but it is far from complete for a complex tool.

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

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

Schema description coverage is 0%, and the description adds no meaning for any of the 11 parameters. Required fields like approval_type and subject are left undefined, and free-form values such as payload_json, required_role, and source_refs_json receive no explanation, so an agent cannot reliably choose values.

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-resource pairing ('Create an approval request') and adds the agent-workflow context, making the tool's purpose immediately clear. It is easily distinguishable from siblings such as gateway_approval_get, gateway_approval_list, and gateway_approval_decide.

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 choose this tool over related approval or access-request tools, and no exclusions or workflow context such as 'use when a human decision is required'. The only usage-related hint is the approvals:write permission, which is a prerequisite rather than a selection rule.

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 an explicit permission requirement, 'Requires approvals:write,' which is meaningful because annotations provide no read-only, destructive, or other behavioral hints. However, it does not disclose the side effects of the decision, whether it is reversible, or what happens when information is requested.

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

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

The description is short, dense, and front-loaded with the core actions followed by the access requirement. Every sentence contributes useful information, though the compactness leaves room for missing 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?

The description is not complete for a decision-making mutation tool: it omits the semantics of the decision payload, the effect of requesting information, possible constraints, and the meaning of the optional comment field. An output schema exists, but the decision workflow and side effects remain underspecified.

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

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

With 0% schema description coverage, the description must compensate, but it only hints at possible decision types: approve, reject, or request information. It does not explain approval_id format, the exact accepted values for decision, the purpose of comment, or how decision_payload_json should be structured.

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 approves, rejects, or requests information on an approval, providing a specific action and resource. It does not explicitly differentiate itself from sibling tools like gateway_approval_comment or gateway_admin_access_request_decide, but the name and intended action make it 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 gives no guidance on when to use this tool versus alternatives such as gateway_approval_comment or gateway_admin_access_request_decide. It only states the required permission, which is useful but not usage guidance.

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

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

The description aligns with readOnlyHint=true by using 'Read', and adds useful context beyond annotations: results are limited to 'visible' approvals, event history is included, and approvals:read permission is required. No contradiction with 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?

A single, front-loaded sentence with no filler. Every phrase earns its place: 'Read', 'one', 'visible', 'event history', and the permission requirement.

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 read-one tool with readOnlyHint and an output schema, the description covers purpose, scope, and permission. It does not explicitly distinguish from sibling approval tools, but the singular 'one' combined with the tool name makes the intended use reasonably clear.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly explains include_events via 'event history' but does not explain approval_id or the default behavior of include_events. Since approval_id is self-evident from the schema and tool name, the gap is moderate rather than severe.

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'), a clear resource ('one visible approval'), and a distinguishing scope ('and its event history'). This separates it from sibling tools like gateway_approval_list, gateway_approval_decide, and gateway_approval_comment.

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

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

The description clearly implies this is the singular read tool for a single approval and its history, and it states the required permission. It does not explicitly name alternatives or when-not-to-use conditions, so it stops short of full routing 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?

readOnlyHint=true already covers the read-only safety profile. The description adds useful context about the required permission and the 'visible or assigned' scope, but it does not disclose pagination, ordering, or how visibility is determined. It neither contradicts the annotation nor fully characterizes 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?

One sentence front-loads the core action and resource, then states the permission requirement. There is no wasted wording or repetition of the schema, title, or annotations.

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

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

Despite having an output schema and a readOnly annotation, the description does not explain accepted values for status, approval_type, or required_role, nor what 'visible' means. With six optional parameters and 0% schema coverage, the definition is too sparse for an agent to use it with confidence.

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 carries the full burden for explaining six parameters. It only gestures toward 'assigned' requests, leaving limit, status, created_by, approval_type, and required_role undocumented. Parameter names alone are not sufficient.

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

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

The description opens with the verb 'List' and identifies the resource 'approval requests,' narrowed by scope ('visible or assigned'). It is clear and separates this from single-item tools like gateway_approval_get, though it does not explicitly name sibling 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 one prerequisite ('Requires approvals:read') but no guidance on when to use this tool versus related sibling tools such as gateway_approval_get, gateway_approval_decide, or gateway_access_request_list. There are no exclusions or alternative routing hints, which is a significant gap given the large sibling list.

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 contain only a title (no readOnly/destructive hints), so the description carries the full behavioral burden. It adds genuine context by disclosing that calls pass through auth, scope checks, and audit logging — the defining behavioral trait of a gateway proxy. But it omits failure behavior, idempotency semantics, and any distinction from gateway_call_tool_sanitized, making it minimally transparent rather than 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?

A single, tightly-written sentence with zero filler; the verb and resource lead, and the governance qualifiers trail cleanly. It is slightly too sparse to carry the needed operational guidance, but that is a completeness issue rather than a conciseness defect.

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 generic pass-through tool with 0% schema coverage and no behavioral annotations, one sentence is insufficient. Missing are parameter semantics, how an agent discovers valid route/tool_name values, idempotency behavior, and the relationship with gateway_call_tool_sanitized. The output schema covers return values, but invocation decisions remain under-informed.

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

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

Schema description coverage is 0%, so the description must compensate, yet it explicitly explains no parameter. 'Private backend route' loosely reinforces that tool_name maps to a Route (consistent with the x-mcp-header hint), while arguments_json and idempotency_key remain undocumented in both the schema and the description.

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

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

States a specific verb ('Call') and resource ('private backend route through GatewayMCP') and adds a distinctive governance qualifier (auth, scope checks, audit), which separates this generic dispatcher from the many domain-specific gateway_* siblings. However, it does not differentiate from its closest sibling, gateway_call_tool_sanitized, and the phrase 'backend route' sits slightly awkwardly against the parameter name tool_name.

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 explicit guidance on when to use this tool versus the large sibling set, and no mention of the most relevant alternative, gateway_call_tool_sanitized. The word 'private' weakly implies it is for routes not exposed by dedicated sibling tools, but the selection rule is left entirely 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's 'read-only' claim aligns with the readOnlyHint=true annotation (no contradiction) and adds the sanitization-before-delivery behavior as useful context beyond the annotation. However, it does not disclose what sanitization does, failure modes, or error behavior; annotations carry most of the safety burden.

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 with no wasted words; the core action is front-loaded. The brevity is efficient, though it borders on under-specification given the parameter gaps.

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

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

For a generic routing tool with three undocumented parameters and safety implications (which routes are callable, what policy controls, what sanitization strips), the description leaves the invocation contract underspecified. The output schema covers returns, but the input contract is unclear.

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 mentions none of the three parameters (tool_name, arguments_json, policy). It adds no meaning beyond names and defaults, leaving the agent to guess how arguments are encoded and what policy values do.

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 ('Call a read-only backend route') plus a distinctive second behavior ('sanitize its result before agent delivery') that separates it from the sibling gateway_call_tool. It is clear, though somewhat generic about what a 'backend route' is and what sanitization entails.

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

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

No guidance is given on when to use this tool versus gateway_call_tool or any other sibling. The agent is left to infer when the sanitized variant is preferred and whether policy/arguments_json should differ, with no when/when-not/alternative 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?

Annotations declare readOnlyHint=true, which covers safety. The description clarifies the nature of the returned data (compact, aggregated from multiple sources) but does not disclose details like pagination behavior, truncation with max_chars, or that it executes multiple underlying queries. It adds some context beyond annotations but lacks behavioral nuance for a composite tool.

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

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

The description is a single sentence, front-loaded with the primary action and content components. It is appropriately concise with no filler, though it sacrifices detail for brevity.

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

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

For a tool with 4 parameters and no schema descriptions, the description is inadequate. It gives a high-level overview but does not explain how parameters affect the output, how the composite result is assembled, or any practical usage details. The output schema exists, so return structure is covered, but parameter semantics and tool selection context remain underspecified.

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

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

Schema description coverage is 0%, and the description provides no parameter explanations. Parameters like limit, query, max_chars, and include_sources are left entirely to be inferred from names and defaults, which is ambiguous (e.g., limit could refer to result count or length). The description fails to compensate for the missing schema documentation.

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

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

The description states a clear purpose: 'Return a compact startup context' and enumerates three specific components (source-of-truth map, company memory, relevant company search results). It distinguishes itself from sibling tools like gateway_company_get_source_of_truth and gateway_company_search by aggregating multiple data sources into one call.

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 is for bootstrapping context, but does not explicitly guide when to use this tool versus calling individual tools (e.g., gateway_company_get_source_of_truth, gateway_memory_search). No when-to-use or when-not-to-use guidance is provided; the intended scenario is only inferred from the name and description.

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

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

The readOnlyHint annotation already marks the operation as read-only. The description adds the 'through Yonote or the matching source-of-truth domain' detail, suggesting a fallback or selection mechanism, but it does not explain what happens on failure, error handling, or truncation behavior related to max_chars. The added context is useful but limited.

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, which is concise and front-loaded, but it is under-specifying. It omits critical details that an agent needs, making it too terse to be fully useful. The length is acceptable, but the content is insufficient.

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 three parameters, no schema descriptions, and an output schema present, the description should explain the 'kind' enum and the 'max_chars' truncation behavior. It does not, leaving the agent with guesswork about how to invoke the tool correctly. The fallback behavior is also vaguely described.

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

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

Schema description coverage is 0%, and the description provides no explanation for the three parameters (kind, item_id, max_chars). An agent cannot infer what valid 'kind' values are, what 'item_id' refers to, or how 'max_chars' affects the result. The description fails to compensate for the lack of schema-level documentation.

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

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

The description states a specific verb ('Resolve') and resource ('one company context item'), and implies a single-item retrieval that differentiates it from search tools. It also hints at a dual-source resolution ('through Yonote or the matching source-of-truth domain'), which separates it from a pure source-of-truth getter, though it does not explicitly name sibling 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?

No guidance is given on when to use this tool versus alternatives like gateway_company_search or gateway_company_get_source_of_truth. There are no conditions, exclusions, or context cues to help an agent decide between them.

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

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

Annotations provide readOnlyHint=true and the description aligns by saying 'Return.' It adds the content-coverage context (people/projects/etc.) but does not disclose any additional behavioral traits such as output truncation, cost/size limits, or pagination beyond the max_chars parameter.

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 16-word sentence, front-loaded with the verb and object, with no filler. All six content categories are packed efficiently 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?

With an output schema and readOnly annotation present, the description is minimally sufficient, but it leaves max_chars semantics and the relationship to sibling company tools unexplained. For a single optional parameter and a simple read operation, this is a moderate gap.

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

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

Schema description coverage is 0% and the description does not mention 'max_chars' at all. It adds no meaning beyond the schema's title and default, so the agent must infer truncation behavior from the parameter name alone.

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

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

The description states a specific verb ('Return') and resource ('company source-of-truth map') and enumerates the content domains (people, projects, processes, documents, decisions, operations). It is clearly distinguishable from siblings like gateway_company_search and gateway_company_get by the 'source-of-truth' scope, though it does not explicitly name alternatives.

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

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

The description gives no guidance about when to use this tool versus gateway_company_get, gateway_company_search, or gateway_company_bootstrap_context. The only usage signal is implied by the name and purpose; there are no prerequisites, exclusions, or context triggers.

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 annotation readOnlyHint=true already establishes the read-only nature. The description adds the detail that the search spans 'the Yonote index and source systems,' which is useful behavioral context, but it does not disclose limits, pagination, or how parameters like max_chars affect results.

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

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

The description is a single, front-loaded sentence with no filler words. It is concise, though it leaves out details that other dimensions require.

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

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

With five parameters and no schema descriptions, the tool definition lacks enough context for an agent to invoke it correctly. The output schema may cover return values, but parameter semantics and usage guidance are 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 description coverage is 0% and the description does not mention any of the five parameters (kind, limit, query, max_chars, include_sources). It therefore fails to compensate for the missing parameter documentation.

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

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

The description states a clear verb and resource: 'Search company context' through the Yonote index and source systems. This conveys that the tool is a read-only company search and gives some differentiation from sibling search tools, but it does not explicitly contrast it with tools like gateway_company_get or gateway_knowledge_search.

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

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

The description gives no guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites. An agent can only infer from the name and phrase 'Search company context' that it is meant for company-related lookups.

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 readOnlyHint=true annotation already establishes that this is a safe read operation, and 'Return' aligns with that. The description adds modest context by mentioning 'normalized' output and the work_id preference, but it does not disclose fallback behavior, identifier precedence, or side effects beyond what annotations already 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?

One compact sentence with the core action front-loaded and no filler. The semicolon clause is terse but purposeful, though it could be more clearly structured.

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

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

For a tool with five optional parameters and no schema-level descriptions, this is under-specified. It does not explain how to select among the identifiers, what tracker_queue or allow_queue_fallback mean, or what 'normalized' runtime config entails. The output schema covers return shape but not invocation semantics.

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

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

Schema description coverage is 0%, so the description needed to clarify all five parameters. It only addresses work_id ('prefer work_id for queued Work Contracts'); issue_id, project_id, tracker_queue, and allow_queue_fallback remain effectively unexplained.

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

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

The description names a specific action and resource: 'Return normalized factory runtime config.' The added clause about preferring work_id for queued Work Contracts provides a useful scoping hint. It does not explicitly differentiate this from sibling factory/read tools, so it stops short of a 5.

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

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

There is no guidance on when to choose this tool over alternatives such as gateway_factory_projects_discover or gateway_factory_project_resolve_by_issue. The 'prefer work_id for queued Work Contracts' clause is a parameter-preference hint, not tool-selection 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?

Annotations already declare readOnlyHint=true, so the read-only nature is known. The description adds that it maps an issue to a runtime project config, but does not disclose any additional behavior such as queue fallback, error conditions, or what 'resolve' entails. It does not contradict annotations, so a mid-range score is appropriate.

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

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

The description is a single concise sentence with no fluff and front-loaded action. It is well-structured, though very sparse; it could carry more useful information without losing conciseness.

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 two parameters (one required, one optional with a default) and a 0% schema coverage, the description is insufficient for an agent to invoke the tool confidently. It does not explain what issue_id should reference, what allow_queue_fallback controls, or how this tool relates to sibling factory tools. The presence of an output schema helps but does not compensate for the missing parameter and 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 description coverage is 0%, and the description provides no explanation for issue_id or allow_queue_fallback. The parameter names offer limited self-evidence, but the tool description adds no meaning – especially the optional fallback boolean, which is left entirely unexplained.

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

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

The description states a specific verb and resource: 'Resolve one Tracker issue to a factory runtime project config.' This clearly distinguishes it from related siblings like gateway_factory_project_get_runtime_config (which likely fetches config directly by project) and gateway_project_scope_resolve. The purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of the allow_queue_fallback parameter's role. The description only states what it does, leaving the agent to infer when it should be chosen over sibling factory or project 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?

The annotation readOnlyHint=true covers the read-only nature, and the description does not contradict it. However, the description adds no additional behavioral context beyond the annotation, such as what happens during discovery, whether it returns a list, or any side effects. Since annotations already cover safety, the description's minimal contribution warrants a low score.

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

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

The description is a single, front-loaded sentence with no wasted words, which is concise. However, it is so sparse that it borders on under-specification, lacking structure or elaboration that would aid an agent. It is not poorly structured, but it does not fully earn its place by adding sufficient value.

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

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

Given the tool's simplicity (two optional parameters) and the presence of an output schema, the description does not need to explain return values. Yet it fails to explain the parameters or usage context, leaving the agent with no understanding of what 'discover' entails or how to filter results. The minimal description is insufficient for effective tool selection and invocation.

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

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

Schema description coverage is 0%, and the description does not mention the 'limit' or 'query' parameters at all. The agent receives no explanation of their meaning, format, or how they affect the discovery. This is a critical gap given the schema provides no descriptions either.

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 ('Discover') and resource ('projects') with a qualifier ('that can be onboarded or executed by the autonomous development factory'), which is clear and distinguishes it from the sibling 'gateway_process_candidates_discover' by focusing on projects rather than process candidates. However, it could be more explicit about what 'projects' means in this context.

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 like gateway_process_candidates_discover or other discovery tools. It does not mention any exclusions, prerequisites, or context for selection, leaving the agent to infer usage.

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 declare readOnlyHint=true, but the description says 'Create a one-time HTTP download session,' which implies a state-changing operation. This is an annotation contradiction, so the score is 1.

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

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

The description is a single concise sentence with no filler. It front-loads the action and object, making it easy for an agent to parse quickly.

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 tool with an output schema, the description covers purpose and precondition. However, the contradiction between readOnlyHint=true and the create action leaves the side-effect profile unclear, so it is not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by specifying that upload_id must reference a completed upload, but it does not explain how to obtain or format the ID. For a single self-named parameter, this is adequate but not thorough.

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') and a specific resource ('one-time HTTP download session') with a clear precondition ('for a completed upload'). This clearly distinguishes it from related upload/status tools.

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

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

The phrase 'for a completed upload' provides a clear precondition and indicates the tool should be used only after an upload has finished. It does not explicitly name alternatives or exclusions, but the context is clear enough.

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?

readOnlyHint already declares the operation is read-only. The description adds the meaningful behavioral constraint that the session must be owned by the current actor, which is useful scoping beyond the annotation. It does not contradict 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?

A single, front-loaded sentence with no filler. The essential information about action, resource, and ownership scope is delivered immediately and economically.

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 read-only tool with an output schema, the description is nearly complete. The only notable gap is not explicitly connecting download_id to gateway_file_download_create, which would complete the download lifecycle 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?

With 0% schema description coverage, the description should help explain download_id. It partially does by establishing that the ID refers to a file download session, but it does not clarify where the ID comes from or how it should be obtained. The parameter remains self-evident but under-documented.

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

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

The description uses a specific verb ('Get'), names the exact resource ('file download session'), and adds a scope ('owned by the current actor') that distinguishes it from related file upload/download tools. It clearly identifies 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 implies usage for checking a file download session's status and imposes an ownership restriction, but it does not explicitly state when to use it versus alternatives or mention the relationship to gateway_file_download_create. The lifecycle context is left 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?

With no annotations beyond the title, the description carries the full burden. It discloses that the session is short-lived and one-time, which is a meaningful behavioral trait, but it does not mention side effects, expiration details, or that this is a write operation. The description gives some transparency but omits important operational context.

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 front-loads the core purpose and key attributes. Every word is essential, and it avoids unnecessary elaboration.

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 role in an upload flow (with siblings like upload_status and download_create) and the 0% schema coverage, the description is insufficient. It does not explain the expected workflow (e.g., after creating the session, how to use the returned URL, or that upload_status should be called afterward). It also lacks details on file size limits or the purpose of sha256, leaving a significant gap for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no parameter details. It does not explain what sha256, size_bytes, or content_type are used for, nor how they should be formatted. The description adds zero value beyond the schema field titles, leaving the agent to guess the meaning of these required inputs.

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

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

The description clearly states a specific action ('Create') on a specific resource ('short-lived one-time HTTP upload session') with the key qualifiers (short-lived, one-time, binary file). It is distinct from the sibling upload_status and download_create tools, making the purpose unambiguous.

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

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

The description implies the tool is for initiating an upload session but provides no explicit guidance on when to use it versus alternatives like gateway_file_upload_status or gateway_file_download_create. It does not mention any prerequisites, sequencing, or when not to use it, leaving the agent to infer from the name and context.

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

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

Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds the useful 'owned by current actor' scoping constraint, but does not disclose behaviors such as not-found behavior, session lifecycle, or whether the session must be active.

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 focused sentence with the operation, object, and scope front-loaded. No filler or repetition of the name/title.

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

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

The tool is simple and benefits from a readOnly annotation and an output schema, but the description alone leaves usage timing and upload_id provenance implicit. It is minimally adequate for a status lookup but relies on sibling-tool names and inference.

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

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

Schema coverage is 0%, and the description does not explain upload_id beyond implying it identifies a file upload session. It does not state how to obtain it (e.g., from gateway_file_upload_create) or any format/expiry semantics, so the description fails to compensate for the missing schema documentation.

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

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

Description states a specific operation (get), resource (file upload session), and access scope (owned by current actor). This differentiates it from sibling upload creation and download status tools without needing schema inspection.

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 on when to call this versus alternatives such as gateway_file_upload_create or gateway_file_download_status. The ownership qualifier is a permission constraint, not a usage condition, leaving invocation timing 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 annotations declare readOnlyHint=true, and the description's 'Show' aligns with that, so there is no contradiction. However, the description adds little beyond the annotation—it does not clarify whether the output includes inherited permissions, scope, or how permissions are presented. With annotations covering the safety profile, a 3 is appropriate because the description adds minimal context.

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

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

The description is a single, efficient sentence with no filler. It is front-loaded with the action and target, making it immediately scannable. No words are wasted, and the structure is clean.

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 has one parameter, an output schema, and a readOnlyHint, the description is too sparse. It does not clarify the parameter's semantics, the scope of 'knowledge spaces' (all or specific), or what 'actor permissions' entails. While the output schema may cover return structure, the description leaves key usage details unexplained, making it incomplete for an agent to call correctly without additional investigation.

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

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

The schema has 1 parameter ('space') with 0% description coverage, and the description does not explain its meaning, format, or behavior. The phrase 'for knowledge spaces' implies the parameter might be a space identifier, but it is ambiguous whether it is optional, how to specify it, or what happens when omitted. The description fails to compensate for the lack of schema documentation.

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

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

The description states a clear verb ('Show') and resource ('current actor permissions for knowledge spaces'), which is specific enough to distinguish from generic listing tools like gateway_knowledge_spaces or gateway_knowledge_space_list. However, it does not differentiate from the closely named sibling gateway_knowledge_audit_access, which likely serves a similar purpose, so it misses an opportunity to disambiguate.

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. There are many knowledge and admin permission-related siblings (e.g., gateway_knowledge_audit_access, gateway_admin_explain_access) but the description offers no conditions, exclusions, or recommended scenarios. The agent is left to infer the use case from the name and context.

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

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

The readOnlyHint annotation already covers safety, and the description adds the useful behavioral fact that this tool is a synonym/delegate for another tool rather than a distinct operation. However, it does not describe what the aliased tool actually does, so behavioral transparency remains limited.

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 only six words and easy to scan, but it is under-specified rather than efficiently concise. It contains no functional content, so brevity here comes at the cost of usefulness.

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

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

The output schema and readOnlyHint cover return structure and safety, but the description still fails to explain what an access audit is, what the space parameter means, or how this alias behaves relative to the canonical sibling. An agent cannot confidently call it based solely on this definition.

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

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

The schema has one property, space, with 0% description coverage, and the tool description says nothing about it. The agent is left to guess whether space is an ID, slug, or something else, so the description provides no compensation for the schema 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 clearly identifies the tool as a compatibility alias for gateway_knowledge_access_audit, which tells an agent that this tool exists to mirror the canonical sibling. It differentiates from the many unrelated sibling tools by naming its target, though it does not state the actual operation performed.

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

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

There is no guidance on when to use this alias versus the canonical gateway_knowledge_access_audit. The word 'compatibility' implies legacy or alternate naming usage, but the description never states a preference, condition, or exclusion.

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

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

Annotations provide no safety hints (no readOnly or destructive flags), so the description carries the full burden. It explicitly discloses the soft-delete behavior and that the document is retained in trash, which is transparent about the non-destructive nature. It does not mention permissions or reversibility details, but the core behavior is clearly communicated.

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, direct sentence that is front-loaded with the action and outcome. No wasted words; every part adds value.

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

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

For a simple delete tool with an output schema and minimal annotations, the description covers the essential purpose and behavior. It does not explain the parameters, but the tool's complexity is low and the sibling context clarifies its role. Missing parameter details are a minor gap.

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

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

The schema has zero description coverage, and the tool description does not explain the 'space' or 'document' parameters. While 'document' is obviously the target and 'space' is the container, the description adds no extra meaning beyond what the parameter names imply. With low schema coverage, the description should compensate but does not.

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

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

The description states the specific action (soft-delete), the resource (markdown document), and the outcome (kept in space trash). This clearly distinguishes it from siblings like gateway_knowledge_document_restore or gateway_knowledge_document_get, and no ambiguity exists 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 implies the usage context: it is the deletion operation for documents, and the soft-delete nature implies that restoration is possible (via siblings like restore tools). However, it does not explicitly mention when not to use it or name alternatives, so it stops 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?

The description aligns with the readOnlyHint annotation by characterizing the action as 'Read', and adds that documents are markdown and located in personal/group knowledge spaces. However, it does not disclose behavior like access requirements, error conditions, or return format, though the output schema may cover some of this.

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

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

The description is a single sentence with no extraneous words, front-loading the core action. It is concise and well-structured.

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

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

Given the low schema parameter coverage and lack of parameter explanations, the description is incomplete for an agent intending to call the tool correctly. The output schema may help, but the description doesn't address the required 'document' parameter or the optional 'space' parameter.

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

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

The input schema has 0% description coverage, and the description does not define the 'space' or 'document' parameters. 'personal or group knowledge space' only vaguely hints at the space param, and 'document' is not described at all, so the agent gets no additional parameter semantics.

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

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

The description uses a specific verb ('Read') and resource ('markdown document'), and clarifies the location ('personal or group knowledge space'). This clearly differentiates it from sibling tools like gateway_knowledge_document_search or gateway_knowledge_document_put.

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 such as search or list. It does not state prerequisites, exclusions, or scenarios favoring this tool, leaving selection entirely to the agent's inference.

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