Expo

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

The description discloses key behavior beyond the annotations: the browser login requirement, the access-token/JWT input, the session-only vs permanent connection distinction, and the no-args link response. This is useful additional context and does not contradict the annotations.

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

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

The description is longer than strictly necessary but every part contributes meaning: browser login, token usage, permanent header configuration, session-only login, and the no-args link behavior. It is front-loaded with the core purpose and remains reasonably concise.

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 one optional parameter, no output schema, and limited annotations, the description provides enough context to understand the auth flow, token lifecycle, and how to invoke the tool. It does not cover error cases or invalid-token behavior, but that is not critical for this simple 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?

The schema only defines an optional 'token' string with no description. The tool description fully compensates by stating that token is a JWT access token pasted by the user, that omitting it returns a login link, and that passing it creates a session-only login. This is complete for the single parameter.

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 this as an authentication tool: it explains the browser login flow, the token input, and the no-args behavior to obtain a link. However, it does not explicitly contrast itself with sibling tools like 'connect', so there is no direct sibling differentiation.

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

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

The description gives explicit usage instructions: call with no args to get the login link, or call with { token: '<jwt>' } for session-only login. It also recommends a header-based permanent connection, which provides useful context. It does not explicitly state when not to use this tool or name alternative auth-related 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds valuable context beyond those: it specifies conditional return values (authenticated:true when all connected, connect_url when credentials missing). This enriches the agent's understanding without contradicting annotations.

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

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

The description is two concise sentences that front-load the core purpose and then elaborate on conditional behavior. No superfluous details; every sentence earns its place.

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

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

With no output schema and no parameters, the description adequately covers the two primary states (all connected vs. missing credentials). However, it omits a possible 'partial connection' state, which could be a minor gap. Still, for a simple status tool, it's sufficiently 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?

There are zero parameters, so the baseline is 4. The description does not need to explain parameters, and the schema is empty. No additional parameter documentation is required.

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 function: 'Returns connection status and URLs.' This is specific (verb+resource) and distinguishes it from siblings like 'authenticate' or 'toolkit_info', which serve different purposes.

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 ('check connection status') but does not explicitly say when to use it versus alternatives like 'authenticate' or 'toolkit_info'. It only describes behavior in different states, not proactive usage guidance 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 indicate readOnlyHint=false, which already signals mutation. The description adds that it uses 'expo install' and may attach usage instructions, but does not disclose side effects like package.json changes, network access, or failure behavior. With limited annotation support, this is moderate disclosure.

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

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

The description is a single sentence, front-loaded with the action and method, and contains no unnecessary words. It is highly concise and structured effectively.

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

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

For a simple two-parameter tool, the description covers the core action but omits return value, error handling, and side effects. With no output schema and minimal annotations, it is adequate but incomplete for an agent to fully anticipate the tool's behavior.

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

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

Both parameters (libraryName, projectRoot) have 0% schema description coverage, and the description does not explain their format or relationship. It only implies that a library is added to a project, leaving parameter meaning largely to inference from parameter names.

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: 'Add an Expo library to the project using expo install'. The verb 'Add' and resource 'Expo library' are specific, and mentioning 'expo install' distinguishes it from documentation or workflow tools among the siblings.

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

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

The description implies use when you want to install an Expo library, but it does not explicitly state when to use this tool versus alternatives (e.g., manual installation or expo_read_documentation). It provides context but no exclusions or 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?

The description adds behavior beyond the annotations by specifying that only queued or in-progress builds can be cancelled and implying a prerequisite status check. It does not contradict the annotations (readOnlyHint=false, destructiveHint=false) and provides meaningful context without needing to repeat structured hints.

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

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

The description is two sentences long, front-loaded with the primary action, and contains no filler. Every sentence earns its place by covering the action and a prerequisite.

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

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

For a simple one-parameter mutation tool with no output schema, the description covers purpose, state restriction, and a usage prerequisite. It omits postconditions and error behavior, but given the tool's simplicity and available sibling context, it is fairly 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?

The input schema only defines buildId as a string with no description, and schema coverage is 0%. The description does not directly define buildId, but the reference to build_info implies where the ID comes from, offering partial compensation. For a single self-explanatory parameter, this is adequate but not fully explicit.

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 ('Cancels'), the target resource ('an EAS build'), and the applicable state ('queued or in progress'). This clearly distinguishes it from sibling tools like expo_workflow_cancel and other build-related operations.

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

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

It gives explicit usage context by instructing the agent to check the current status with build_info before cancelling. However, it does not explicitly state when not to use it or name alternative cancellation tools, so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing what kind of information the tool retrieves (status, errors, artifacts), which is not apparent from the schema or annotations alone. This gives the agent an expectation of the return content.

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 long, with the primary purpose front-loaded and the usage guidance in the second sentence. There is no extraneous information, making it highly 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?

The tool has a single parameter, no output schema, and good annotations. The description covers the return content (status, errors, artifacts) sufficiently for an agent to understand what to expect. It lacks some detail about response format, but given the low complexity, it is nearly 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 mentions 'by ID', which clarifies that buildId is the build identifier, but does not provide additional format or source guidance. For a single simple parameter, this is adequate but not enlightening.

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 the specific verb 'Fetches' and clearly identifies the resource as a specific EAS build by ID with status and detailed information. It distinguishes from sibling tools like expo_build_list (lists builds) and expo_build_logs (logs) by focusing on a single build's status, errors, and artifacts.

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

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

The description explicitly states 'Use this to check build status, errors, artifacts, and other details,' providing clear context for when to use this tool. It does not explicitly mention alternatives or exclusions, but the use case is clear enough to differentiate from siblings.

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, destructiveHint=false, idempotentHint=true, covering safety and side-effect profile. Description adds that it provides 'status and available artifacts' but does not disclose pagination, ordering, or whether the OR condition is mutually exclusive. Nothing contradicts annotations.

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

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

Two sentences, no filler, front-loaded with the core purpose. Every clause adds value: the OR condition and example are necessary for correct invocation.

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

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

For a read-only listing tool with all optional params and no output schema, the description covers the essential invocation requirement (appId vs appFullName). It could mention that status is filterable and that limit applies, but the schema enums already handle that. Slightly incomplete for a tool that is one of many build-related siblings, but adequate.

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 description carries the burden. It explains the meanings of appId and appFullName (with source and example), and implies limit/status/platform by the context of listing builds, though it doesn't detail them. This compensates better than baseline 3.

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 it 'Lists EAS builds for a project' – a specific verb and resource. It distinguishes from siblings like expo_build_info (singular build) and expo_build_logs (logs) by focusing on listing builds with status and artifacts.

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

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

Explicitly instructs how to identify the project: provide either appId OR appFullName, with a concrete example format. It implies when to use (to see recent builds) and differentiates from other build-related tools by listing what it returns.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds only the post-build availability condition, which is useful but not richly detailed; it doesn't specify what happens if the build is incomplete or how logs are returned.

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 concise sentences with no filler. It front-loads the main purpose and then adds a necessary prerequisite, making every sentence valuable.

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-parameter read-only tool with good annotations, the description adequately conveys purpose and the key constraint. The lack of an output schema is not a major issue since 'fetches the logs' implies the return type, though explicit details about response structure would make it 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?

The schema has 0% description coverage, and the description only identifies buildId as 'a specific EAS build.' It doesn't explain where to obtain buildId or any format expectations, though the single parameter name is reasonably self-explanatory.

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 it 'Fetches the logs for a specific EAS build,' naming the exact action, resource, and scope. The phrase 'specific EAS build' differentiates it from list- or info-oriented sibling tools, though it doesn't 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 provides an important usage condition: the build must be completed (finished or errored) for logs to exist. This implies the tool is only useful for completed builds, but it doesn't explicitly mention alternative tools or exclude use cases.

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?

Annotation contradiction: openWorldHint=false conflicts with the description's 'Triggers a new EAS build' and GitHub prerequisite, which imply interaction with external EAS/GitHub services. The description also does not disclose side effects such as queuing, cost, or asynchronous build behavior.

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

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

The description is two front-loaded sentences with no filler. Every clause adds meaningful information about purpose, prerequisites, and parameter selection.

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 8 parameters, no output schema, and no parameter descriptions, the description is far from complete. It leaves required gitRef semantics unclear and creates ambiguity around appId/appFullName despite schema marking them optional.

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 only clarifies appId and appFullName, while the required gitRef and other parameters such as autoSubmit, baseDirectory, and submitProfile remain undefined.

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?

Clearly states it triggers a new EAS build using a build profile from eas.json. This distinguishes it from sibling tools like expo_build_cancel, expo_build_list, and expo_build_logs.

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

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

Provides clear usage prerequisites: a connected GitHub repository and either appId or appFullName. It does not explicitly name alternatives or when-not-to-use cases, but the context is sufficient for basic selection.

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

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

Annotations already indicate this is not read-only, not idempotent, and not destructive. The description adds useful constraints (finished build, distribution type) and app identity prerequisites, but does not disclose side effects like triggering a store review, potential irreversible submission, or authentication requirements. This adds some value beyond annotations, so a 3 is warranted.

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 primary action, and includes essential prerequisites and a choice of parameters without unnecessary detail. Every sentence contributes 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 6-param tool with no output schema, the description covers the main purpose, prerequisite build state, and app identity selection. But it omits meaningful semantics for optional parameters (track, ascAppIdentifier) and does not indicate what the response might contain or whether submission is asynchronous. These are clear gaps for a submission tool, so a 3 is appropriate.

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 has 0% description coverage, so the description must compensate. It explains appId ('from app.json extra.eas.projectId') and appFullName ('@owner/my-app') and implies platform via the enum. However, buildId, track, and ascAppIdentifier are not explicitly described, leaving partial ambiguity. This is a minimum-viable compensation, hence a 3.

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 ('Submits an EAS build to the app store') and specifies the platforms (Google Play, App Store). This distinguishes it from sibling tools like expo_build_run, expo_build_cancel, and expo_build_info by focusing on the submission step.

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

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

Provides clear context for when to use: requires a 'finished build with the appropriate distribution type', implying it should be used after expo_build_run or similar. It also clarifies the app identification options, but does not explicitly name alternatives or exclusions, so a 4 is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a key behavioral trait by stating it 'remember[s] it for future conversations', indicating persistent internal knowledge. This does not contradict the annotations, as the memory change is internal and non-destructive.

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

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

Two short sentences with the most important information front-loaded. There is slight redundancy between 'Learn Expo how-to...' and 'Use this to teach the assistant', but no filler or unnecessary detail.

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

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

For a simple one-parameter tool with helpful annotations and no output schema, the description adequately covers the purpose and the unique memory behavior. It lacks guidance on how the learned knowledge is applied or when to prefer this over documentation tools, but the overall simplicity lowers the burden.

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 says 'specific topic' without mentioning the enum or that the only supported value is 'expo-router'. The schema itself constrains the parameter, but the description adds no value beyond what the schema already provides.

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

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

The description uses a specific verb 'Learn' with a clear resource ('Expo how-to for a specific topic') and explicitly states the tool is for teaching the assistant. This differentiates it from sibling tools like expo_read_documentation and expo_search_documentation by emphasizing the 'remember it for future conversations' aspect.

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

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

Provides clear context on when to use: 'Use this to teach the assistant about specific Expo features or workflows'. However, it does not explicitly mention alternatives or when not to use it compared to documentation read/search tools, which are obvious siblings.

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 state readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable context: it returns markdown, has a ~5000 token limit per call, and supports offset pagination. This goes beyond the structured fields without contradicting them.

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

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

Two sentences, front-loaded with the main purpose, and no filler. The first sentence establishes the core action and output format while the second gives the practical pagination needed for long pages.

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 tool with no output schema, the description covers what the tool returns (markdown), its throughput limit, and pagination. Given the sibling ecosystem and the tool's name, this is fairly complete for an agent's invocation decision, though it could briefly mention a maximum offset or error behavior.

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 burden. It explains 'offset' as a pagination mechanism, adding some meaning beyond the bare number type. However, it doesn't clarify param details such as whether offset is a token offset or page index, and the 'url' parameter semantics are implied but not explicitly spelled out.

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 starts with a specific verb ('Fetch') and a clear resource ('a single Expo documentation page'), states the output format (markdown), and includes the return limit. This clearly distinguishes it from the sibling 'expo_search_documentation' tool, which presumably finds pages rather than fetching a single page's content.

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 actionable usage guidance: 'Use offset to paginate through long pages.' This tells the agent how to handle pagination. It doesn't explicitly list when to prefer this over expo_search_documentation, but the task is clear enough from the name and description that guidance is mostly implied rather than missing.

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 and idempotentHint=true, so the description doesn't need to repeat that. It adds the ranking by relevance behavior but does not mention any limits (e.g., number of results, pagination). With annotations covering the safe-read nature, a 3 is fair as it adds some but minimal extra 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?

Two sentences, front-loaded with the main action and followed by a clear usage link. Zero waste.

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 relatively simple (search returning URLs), and annotations provide safety hints. However, the description does not mention what the output looks like (e.g., list of URLs with titles) or that results are limited. Since there is no output schema, the description could have clarified the return format, but it's sufficient for an MVP.

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 only one parameter 'query' with no description. The tool description says 'user query' which adds a little meaning, but it doesn't specify format, expected length, or examples. For a simple string, this is acceptable but not sufficient to exceed baseline.

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 it searches Expo documentation and returns page URLs ranked by relevance, distinguishing it from sibling tools like expo_read_documentation which fetches content.

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

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

It explicitly instructs to use read_documentation to fetch full content starting from the top, which provides a clear follow-up action. However, it does not mention when not to use this tool (e.g., for specific known pages).

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

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

Annotations already establish readOnlyHint, idempotentHint, and non-destructive traits, so the bar is lower. The description adds essential behavioral context beyond annotations by explaining the mode-switching behavior (presence of crashId alters return payload). It does not contradict annotations, and for a simple read-only fetch, no rate-limit or auth disclosure appears critical here.

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, front-loaded with the core purpose and followed by a tightly worded conditional. Every clause contributes: the first identifies the resource, the second defines both branches of behavior. No redundant terminology, no filler.

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

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

For a 3-parameter read-only tool with no output schema and no nested objects, the description covers the essential behaviors and the interplay between list/detail modes. It could hint at what a 'recent' crash means or confirm that the list contains crashIds for follow-up calls, but given the tool's relative simplicity, the gaps are minor.

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

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

With 0% schema description coverage, the description carries the burden and largely compensates by explaining crashId's semantic role as the mode selector. While limit and bundleId aren't explicitly described, their semantics are low-ambiguity (numeric cap and app identifier), and crashId was the parameter most in need of clarification. Marginal gap remains on limit's transformation behavior in list mode.

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

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

The description opens with a specific verb+resource pair ('Fetch TestFlight crash data') that clearly scopes the tool's function and differentiates it from siblings like expo_testflight_feedback and expo_build_list. It further clarifies dual-mode behavior (list vs. full log), leaving no ambiguity 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 explains when to use each mode ('Without crashId, lists recent crashes. With crashId, returns the full crash log with stack trace'), giving clear conditional context. However, it doesn't explicitly name alternatives or exclusions (e.g., directing users to expo_testflight_feedback for feedback data, which is a natural sibling to distinguish from).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations by specifying the return contents: metadata including device info, user comments, and screenshot URLs. It does not discuss pagination or authorization, but with strong annotations this is sufficient.

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 immediately states the tool's purpose and then concisely lists returned content. Every word earns its place; there is no repetition or filler.

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

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

For a simple read-only fetch with two parameters and no output schema, the description explains the source and return content adequately. However, it omits crucial parameter semantics (especially the required bundleId) and does not mention whether results are paginated or limited, leaving clear gaps in context.

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

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

Schema description coverage is 0%, so the description must compensate by explaining bundleId and limit. It names neither parameter, leaving their meaning entirely to the bare schema names. The description adds no value beyond what the schema fields themselves already show.

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 ('Fetch') and resource ('screenshot feedback from TestFlight'), clearly distinguishing it from the sibling tool expo_testflight_crashes. It states exactly what type of data is retrieved.

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 the tool is for retrieving TestFlight screenshot feedback, but it does not explicitly mention when to use it over alternatives like expo_testflight_crashes. No exclusion or alternative guidance is provided, leaving usage context implicit rather than explicit.

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

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

The description adds little beyond the name and annotations. Annotations indicate readOnlyHint=false and destructiveHint=false, but no additional behavioral context (e.g., whether cancellation is reversible, idempotent, or requires special permissions) is disclosed. For a mutation tool, this is a significant 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?

Two sentences, front-loaded with the action, and no wasted words. Each sentence earns its place by stating the function and providing the source for the required ID.

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 (one parameter, no output schema), and the description covers the operation and the parameter source. While it doesn't mention edge cases (e.g., canceling an already-finished workflow), the simplicity and sibling context make it reasonably 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%, but the description compensates by explaining that workflowRunId can be obtained from workflow_info, which gives the parameter practical meaning. For a single self-explanatory string parameter, this is 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 uses the specific verb 'Cancels' with the resource 'running EAS workflow', clearly distinguishing it from sibling tools like expo_build_cancel and expo_workflow_info. It also indicates the necessary context (a running workflow) without ambiguity.

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

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

The description provides clear context by stating the tool cancels a running workflow and explicitly instructs to use workflow_info to get the workflow run ID, which is an actionable prerequisite. It lacks explicit alternatives or when-not-to-use guidance, but the context is sufficient for this simple operation.

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

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

With annotations providing no hints (readOnlyHint=false, destructiveHint=false, etc.), the description carries the burden of explaining side effects. It states that creating a file is a write operation, but it doesn't disclose whether it overwrites existing files, whether it requires authentication, or what happens if the file already exists. The 'learn' action is likely non-destructive, but this isn't explicitly stated. The description adds some context but lacks details on failure modes or side effects.

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

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

The description is concise, with two sentences that pack a lot of information. It front-loads the primary purpose (creating the file) and adds the secondary action (learning). It also mentions the validation follow-up. No redundant words, and it's appropriately structured. Minor deduction for not breaking down the two modes more clearly, but overall efficient.

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

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

Given the tool has 4 parameters, no output schema, and zero schema description coverage, the description is incomplete for an agent to use it correctly. It doesn't explain the 'action' parameter's role in determining create vs. learn, nor does it specify what inputs are needed for each mode. It also doesn't mention prerequisites (like authentication or having an Expo project). The description gives high-level guidance but lacks operational detail, making it insufficient for complex usage.

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%, meaning the description does not explain any parameters. The input schema lists parameters like action (with enum create/learn), fileName, projectRoot, and workflowYaml, but the description does not describe what each parameter means or how they are used. For example, it doesn't clarify that workflowYaml is the content of the YAML file, or that projectRoot is the root directory. This is a significant gap, as 4 parameters are undocumented in the description, forcing the agent to infer from names.

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 that the tool creates a new EAS workflow YAML file or fetches syntax documentation, which distinguishes it from sibling tools like expo_workflow_validate and expo_workflow_run. It specifies the target location (.eas/workflows/) and the two primary actions (create and learn). However, it could more explicitly state that this is for creating workflows (as opposed to other workflow operations), but the verb 'Creates' and the resource 'EAS workflow YAML file' are specific 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 provides clear guidance on when to use the tool: 'Use this when users want to create CI/CD workflows in .eas/workflows/ or need to learn EAS workflow syntax.' It also points to an alternative for validation: 'After creating, use workflow_validate to validate the file.' This gives context on the next step, though it doesn't explicitly state when not to use it (e.g., for running or inspecting workflows).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to cover safety. It adds the detail that results include job dependencies and suggests diagramming multiple jobs, which is useful context beyond annotations.

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

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

The description is concise with two sentences. It front-loads the main purpose and then adds a useful note about diagramming job dependencies, which is actionable. 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?

The tool is simple (one parameter, no output schema) and the description covers what it does and what it returns conceptually. It also provides a unique instruction about diagramming dependencies, which suggests a richer insight for the agent. Adequate for the complexity, though it could specify the exact fields returned.

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 only one parameter with 0% description coverage, so the description should explain the parameter. It mentions the workflowRunId is used to fetch info, but doesn't add format or constraints beyond the schema's basic string type. Since there's only one parameter and the purpose is clear, this is adequate but not enriched.

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 fetches detailed information about a specific EAS workflow run by ID, including status, job results, errors, and artifacts. It distinguishes from siblings like expo_workflow_list (list all) and expo_workflow_logs (logs) by focusing on a single run's detailed info.

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 specifies when to use it: to check status, job results, errors, and artifacts of a workflow run. It implies this is for post-run inspection, but does not explicitly state when not to use it or mention alternatives like expo_workflow_logs for logs.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description only adds modest context like 'recent' and project identifier options. No additional behavioral traits (e.g., pagination, ordering) are disclosed, but the safety profile is fully covered by annotations.

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

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

Two concise sentences with the main purpose first, then parameter guidance. No fluff or repetition of schema fields. Efficient and front-loaded.

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

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

For a simple list tool with no output schema and strong sibling coverage, the description is adequate. It covers the essential identification parameters but lacks mention of pagination, default limit, or sorting. Given the tool's low complexity, this is sufficient.

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%, so the description carries the load. It explains appId and appFullName in detail, including how to find appId and the format of appFullName. It omits explanation of 'limit' and 'status', though 'status' has an enum and 'limit' is self-explanatory. This partial compensation is strong enough for a 4.

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

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

The description clearly states the tool lists recent EAS workflow runs for a project, which is specific and distinct from siblings like expo_workflow_info or expo_workflow_logs. The verb 'lists' and resource 'workflow runs' make 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 provides explicit guidance on how to specify the project using either appId or appFullName, with the source of appId and a format example. It doesn't explicitly contrast with siblings for when to choose list over info/logs, but the purpose is clear enough for typical use.

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 indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context about the two-step workflow (summary vs. section fetch), which is beyond what annotations provide. However, it does not detail what data is returned or any rate limits, but with annotations covering the core traits, a 4 is justified.

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

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

The description is concise, two sentences, front-loaded with the main action, and provides the two-step usage essentially. Every sentence earns its place with no fluff.

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 4 parameters, 2 required, no output schema, and rich annotations, the description covers the essential usage pattern. It doesn't mention the return format, but with no output schema and a clear action, it's reasonably complete. It lacks explicit mention of error cases or the exact meaning of phase vs sectionIndex, but the two-step guidance helps.

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 parameter meaning. The description explains that sectionIndex or phase are used to fetch a specific section, and that omitting them yields a summary. However, it does not explain each parameter in detail (e.g., jobKey, workflowRunId) beyond what the schema provides. It adds some value but not comprehensive.

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 fetches logs for a specific job in an EAS workflow run, with a specific verb and resource. It distinguishes from siblings like expo_build_logs by specifying it's for EAS workflow runs, and provides a two-step usage pattern to get a summary then fetch a specific section.

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

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

The description explicitly instructs when to call without parameters (to get a summary of sections) and when to call with them (to fetch a specific section). This provides clear context for usage, though it doesn't explicitly mention alternatives, the two-step pattern is explicit and useful.

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 signal non-read-only, non-idempotent, and non-destructive behavior; the description adds the prerequisite that the workflow file must exist at the git reference. It does not disclose async behavior, return value, or how to monitor the triggered run.

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 carry all key information; the first sentence front-loads the action, and the second packs identifier alternatives and the prerequisite. No filler.

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

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

For a side-effecting run tool with 4 parameters and no output schema, the description covers prerequisites and identification alternatives. It could improve by specifying what the trigger returns or that the run is asynchronous.

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 has 0% description coverage, so the description compensates by explaining appId's source, appFullName's format, and the OR relationship, and by implying fileName is the workflow file and gitRef selects the git reference. It could be more explicit about fileName and gitRef formats.

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 opens with a specific verb and resource: 'Triggers an EAS workflow run from a git reference.' This clearly distinguishes it from sibling workflow tools such as create, validate, cancel, info, and logs.

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

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

It gives clear invocation context by identifying the project via appId or appFullName and states the prerequisite that the workflow file must exist at the git reference. It does not explicitly name alternatives or exclusions, but the context is sufficient.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context that validation happens after creation and requires app identity via appId or appFullName, which goes beyond the schema.

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

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

The description is two sentences with no filler. The first sentence states the action and object, and the second provides usage timing and parameter guidance. Every sentence earns its place.

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

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

For a simple validation tool with only three flat parameters, the description covers purpose, timing, and identifier selection. The lack of detail about workflowYaml format and expected output is a minor gap, but overall the description is sufficient for an agent to select and invoke the tool in most cases.

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 does explain the appId/appFullName either-or relationship and appId provenance, but it adds no meaning for the required workflowYaml parameter, which is the core input. This is a notable 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 begins with a specific verb and resource: 'Validates EAS workflow YAML syntax and configuration.' This clearly distinguishes the tool from sibling workflow tools like create, run, info, list, and cancel.

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

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

It explicitly says to use this 'after creating a workflow to ensure it is valid,' providing clear contextual timing. It does not state when not to use it or name alternatives, so it falls short of a 5.

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

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

Given that annotations only provide readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, the description carries heavy responsibility. It discloses that invoke runs tools without permanent installation, returns connect/checkout links when credentials/payment are needed, and that writes require workspace owner/admin. It also explains that installed MCPs appear natively in future sessions. This is rich behavioral context beyond the annotations, including side effects and prerequisites.

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 long paragraph covering many features; it is information-dense but not front-loaded with a clear summary. The key 'KEY:' highlight helps, but overall the structure could be improved with bullet points or clearer separation between MCP catalog vs prompt library. Every sentence adds value, but the lack of visual structure reduces skimmability. It is not overly verbose for the complexity, but could be better 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 tool's complexity (23 params, 14 actions, two major sub-features), the description covers the main workflow, authentication expectations, and error handling links. It does not describe return formats or output schemas (as none exist), but for a tool that delegates to many sub-operations, it is reasonably complete. Missing details like specific parameter semantics for billing actions (subscribe/cancel with tier_slug) are implied by names and the general context. It lacks a mention of pagination for list_tools or search, but that is minor.

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

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

With 23 parameters and 0% schema description coverage, the description must compensate heavily. It does explain the core parameters (action, query, mcp_id, tool_id, arguments) by mapping them to workflow steps: 'action=search discovers MCPs by intent → describe returns one MCP's full profile...' and 'invoke RUNS that tool'. It also clarifies action enum values like subscribe/cancel/report_bug/request_mcp. However, many parameters (limits, cancel_reason, prompt_*, request_*) are not individually described, but the general flow gives enough context for an agent to infer their meaning from names.

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 that marketplace is the official mcp.ai catalog and execution platform, explaining its dual role of discovery and running tools. It lists specific use-case phrases and distinct actions (search, describe, invoke, install), distinguishing it from sibling tools like expo_* or authenticate. However, the name 'marketplace' is broad and the description bundles many features under one tool, which slightly dilutes the single-purpose clarity.

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 explicit guidance on when to use which action: 'prefer invoke for a single/occasional use' vs 'use install only to make an MCP PERMANENT in the active toolkit', and differentiates between the prompt library and MCP search. It also covers edge cases like connect links and checkout links, and mentions access restrictions for writes requiring owner/admin. This goes beyond basics to explain decision-making between alternatives.

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

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

Annotations already indicate this is not read-only and is idempotent, so the description does not need to restate those. It adds the useful behavioral note about including recent messages for reproduction, but it does not disclose what happens after submission or any other side effects beyond what annotations imply.

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

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

The description is two sentences, front-loaded with the tool's purpose and followed by a single actionable instruction. Every sentence earns its place with no redundant wording.

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 feedback tool with no output schema, the description covers the main use case and one parameter. However, the incomplete parameter semantics and the string-vs-array mismatch leave gaps that could confuse an agent trying 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%, so the description must compensate for the undocumented parameters. It only explains the conversation parameter, and it misleadingly calls it an 'array' while the schema defines it as a string. The required 'message' parameter and the 'context' parameter are not explained 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 tool's purpose: reporting a bug, missing feature, or sending feedback. It uses a specific verb and resource, though it does not explicitly differentiate itself from sibling tools like expo_testflight_feedback.

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

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

The description gives clear context for when to use the tool—when the user reports a bug, missing feature, or wants to send feedback. It also provides a concrete instruction to include the conversation array, but it does not mention exclusions or alternatives.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to establish the safety profile. The description adds the useful detail that BOTH platform and adapter versions are returned, which goes slightly beyond the tool name alone. It doesn't over-explain a simple operation.

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

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

A single, front-loaded sentence that conveys complete meaning with zero filler. Perfectly sized for the tool's simplicity.

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 minimal complexity (0 parameters, no output schema, no nested objects), the description is fully complete. It tells the agent exactly what to expect without unnecessary elaboration.

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 zero parameters, the 100% schema coverage is vacuous, but the rubric sets a baseline of 4 for this case. The description provides all necessary context since there's no parameter syntax or format to document.

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 ('Show') and resource ('current MCP platform and adapter versions'). It clearly distinguishes this from sibling tools like `connect` or `expo_build_run`, making it evident this is a version-inspection utility.

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?

While it doesn't explicitly name alternatives, the context is clear: this is the tool to call when version information is needed. The simplicity of the tool combined with the contrast against feature-heavy siblings makes the usage context self-evident, though it lacks explicit exclusionary language.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is established. The description adds useful context about what the returned state contains, but does not disclose additional behavioral traits such as freshness, caching, network dependence, or error behavior beyond what annotations already cover.

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 immediately states the action and resource, then uses a colon and list to efficiently enumerate the returned information. Every part earns its place with no redundant wording.

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 simple, parameterless status tool with strong annotations and no output schema. The description adequately explains what the tool returns—installed MCPs, connection status, accounts, and catalog tool counts—which is sufficient for an agent to invoke it confidently.

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 an empty input schema, so there are no parameter semantics to clarify. The description correctly focuses on the return value instead, which is the only meaningful semantic content for this tool.

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 the specific verb 'Returns' and clearly identifies the resource as the current toolkit state. It enumerates the exact contents—installed MCPs, connection status, connected accounts, and catalog tool counts—which distinguishes it from sibling tools like show_version or expo_build_info.

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 a clear use case: when an agent needs an overview of the current toolkit integrations and their status. It does not explicitly name alternatives or exclusions, but the tool's purpose is distinct enough that no sibling appears to be a competing alternative.

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