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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read-only operation by using 'Get', but does not mention authentication, rate limits, response format, or any side effects. This is acceptable for a seemingly simple status read but lacks depth.

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 front-loads the core action and outcome. Every word contributes to the meaning, with no fluff or redundancy, making it highly efficient for an agent to parse.

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 parameter, no output schema, and no annotations, the description covers the primary return value (status per platform and 10 recent builds) adequately. It does not explain what 'status' might entail or how to interpret it, but given the simplicity, it is largely 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 provides 100% coverage for the sole parameter (projectId) with a clear description 'Venelx project ID', so the baseline is 3. The tool description does not add any additional meaning about the parameter, such as constraints or how it relates to the per-platform aspect.

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 ('Get') and resource ('current build pipeline status per platform plus the 10 most recent builds') for a project. It is distinct from siblings like trigger_build (trigger action) or list_projects (project enumeration), so an agent can easily tell what this 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 what the tool does but does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or preferred contexts. An agent could infer use for status checks, but the lack of explicit routing to siblings like trigger_build or tail_logs leaves some ambiguity.

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

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

With no annotations provided, the description must disclose behavioral traits. It only says 'Get full details' and mentions a 'GitHub access state' summary. It does not mention read-only nature explicitly (though 'get' implies it), error behaviors, authentication requirements, rate limits, or any side effects. The description relies on the verb to convey safety, which is insufficient for a tool with zero annotation coverage.

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 concise sentence that front-loads the core action ('Get full details') and then adds the additional relevant detail about GitHub access state. 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?

For a single-parameter read tool, the description adequately conveys what the tool returns ('full details' and 'GitHub access state summary'), but it does not mention possible failure modes, required permissions, or how the projectId is obtained. Given the absence of annotations and output schema, a bit more context (e.g., error handling) would improve completeness, but the current level is acceptable for a straightforward get operation.

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

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

The input schema fully covers the single parameter 'projectId' with a clear description ('Venelx project ID'). Since schema coverage is 100%, the baseline is 3. The description does not add any additional meaning beyond what the schema already provides, so it stays at 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 a specific verb ('Get') and a specific resource ('full details for one Venelx project'), and adds a distinguishing detail ('including a summary of its GitHub access state'). This distinguishes it from siblings like list_projects (which lists multiple projects) and github_access (which may focus solely on access details). An agent can easily tell what this tool does without opening the schema.

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 retrieving a single project's complete details, which is implicitly different from list_projects. However, it does not explicitly mention alternatives or when not to use this tool (e.g., 'for multiple projects use list_projects'). The context is clear but not explicit enough to fully guide an agent's decision among several similar tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the return structure but does not state whether the operation is read-only, requires authentication, makes network calls, or what side effects (if any) occur. The label of the credential source hints at an auth dependency, but that is under-explained.

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-loading the purpose and including the return structure. It is concise with no filler, though the literal format string ('githubAccess {ok, reason, message}') could be clearer to an agent unfamiliar with the notation.

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 (one parameter) and no output schema, the description provides a basic overview of the return fields (ok, reason, message) and the credential label. However, it does not explain the meaning of these fields or how to interpret them, leaving some ambiguity for an agent deciding how to act on the result.

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 already fully describes projectId with 100% coverage. The description adds no extra semantic meaning beyond what the schema provides; it simply repeats 'for a project'. Baseline 3 is appropriate given the high schema coverage.

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

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

The description states a specific verb ('Diagnose') and resource ('GitHub repository access for a project'), and even previews the return shape. It is clearly distinct from sibling tools like list_projects or build_status, which are about listing or building rather than access diagnosis.

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 explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It does not mention situations where one might prefer get_project or another sibling. An agent must infer the tool's applicability solely from its purpose.

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 at all, the description carries the full burden of behavioral disclosure, yet it only restates the operation. It doesn't mention return format, ordering, whether results are paginated, or what artifact types are included beyond 'installable binaries etc.'.

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 '(installable binaries etc.)' parenthetical is slightly loose but does not add meaningful bloat.

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 param, no output schema, no nested objects), so the description covers the basic contract. However, for a read operation with zero annotation coverage, it is thin on what the caller receives and how it relates to build_status or trigger_build.

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

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

Schema coverage is 100% — the sole parameter projectId is already described as 'Venelx project ID' in the schema. The description adds no parameter meaning beyond that, so the baseline of 3 for full coverage applies.

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

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

States a specific verb ('List') plus resource ('build artifacts') scoped to a project, which is clear and distinguishable from siblings like trigger_build and build_status. The qualifier '(installable binaries etc.)' slightly dilutes precision but the core 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?

No guidance on when to use this tool versus list_projects, build_status, or signing_status. The only context is 'for a project', which implies a relationship to build outcomes but never explicitly routes the agent away from alternatives or states prerequisites.

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

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

With no annotations, the description carries the disclosure burden. It states the list is limited to projects 'the API token can access', which is a useful permission constraint, and enumerates the returned fields, giving the agent a clear expectation of the output shape. It does not explicitly state read-only status, but 'List' inherently implies a non-mutating operation, and no other behavioral caveats are necessary for a simple list.

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, well-structured sentence that front-loads the action ('List all Venelx projects...') and then lists the returned fields. There is no waste or redundancy, and every word contributes to utility.

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 list operation with no parameters and no output schema, the description covers the essentials: scope ('all accessible'), permission constraint ('the API token can access'), and the exact return fields. Nothing critical is missing for an agent to invoke and interpret the result.

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

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

The tool has zero parameters, so the description needs no parameter information. The schema is trivially complete with 100% coverage, and the description correctly avoids fabricating parameter details, yielding the baseline score for a 0-parameter 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 states a specific verb 'List' and resource 'Venelx projects', and clarifies it returns all accessible projects with specific fields (id, name, GitHub URL, platforms, role). The 'all' qualifier distinguishes it from the sibling tool get_project, which is singular, 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 listing all projects, which is a clear usage context, and the sibling get_project suggests an alternative for a single project. However, it does not explicitly mention alternatives or provide exclusions, so it lacks the explicit routing seen in higher-scoring descriptions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'List' which implies a read-only operation, but does not explicitly mention authentication needs, pagination, or side effects. It does add that workers are scoped to the current account, which is useful context. However, the description is minimal and does not go beyond the obvious behavior of a listing 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?

The description is a single, efficient sentence that front-loads the core action and scope, followed by a parenthetical list of returned fields. No wasted words. Structure is optimal for a tool with no parameters.

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 complexity (0 params, no output schema), the description is fairly complete. It tells the agent what data will be returned (name, status, capabilities), which substitutes for an output schema. It omits any mention of pagination or error conditions, but for a simple list operation this is acceptable. It does not cover potential 'when to use' alternatives, which is captured under usage guidelines.

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 the schema reflects that with an empty properties object. Per the rubric, a baseline of 4 applies when there are no parameters to document. The description adds no parameter information because none exist, but it still clarifies the output fields, which is slightly beyond 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 a specific verb ('List'), a resource ('build workers'), and a scope ('owned by the current account'). It also specifies the returned fields (name, status, capabilities), which differentiates it from siblings like list_projects that target a different resource. 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 guidance on when to use this tool versus alternatives. While the purpose implies use for inspecting workers, there is no mention of when not to use it or how it relates to siblings like list_projects or get_project. The agent must 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'check' which implies a read-only operation, but it does not explicitly confirm non-mutation, describe the output structure (e.g., per-platform readiness, overall status), or mention edge cases like missing certificates or platform unavailability. Without annotations, this lack of detail 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?

The description is a single, concise sentence that front-loads the primary purpose and then mentions the optional filter. Every word earns its place, and it is immediately scannable for an agent.

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 only two parameters and no output schema, the description is adequate but incomplete. It explains the purpose and platform filter, but lacks context on what 'code-signing readiness' entails, what the response looks like, and when an agent would prefer this over sibling tools. Given the simplicity, it does not fully equip an agent to interpret the result or handle errors.

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

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

Schema coverage is 100%, so both parameters (projectId and platform) are already documented with descriptions. The description adds minimal value by restating the platform filter ('Optionally filter by platform'), but it does not provide deeper semantics (e.g., acceptable values for projectId format or how the filter affects output). Baseline 3 is appropriate given high schema coverage.

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

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

The description states a specific verb and resource: 'Check code-signing readiness for a project.' This clearly distinguishes it from siblings like build_status or trigger_build, which relate to builds rather than signing. However, 'code-signing readiness' could be more explicitly defined (e.g., whether it involves certificate checks or provisioning), but the core purpose is clear.

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 explicitly state when to use this tool versus alternatives. It mentions optional platform filtering but gives no guidance on prerequisites, typical scenarios, or when not to use it (e.g., if a build is needed, trigger_build might be more appropriate). The purpose is clear enough that an agent could infer usage, but explicit routing is absent.

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

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

No annotations are provided, so the description carries the full burden. It discloses the key behavioral trait of defaulting to the latest build, but it does not mention error handling, permissions, or any side effects. Since it is a read-only operation ('Return'), the core behavior is clear, but additional safety or failure-mode context is missing.

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 action and includes the key default behavior. Every word earns its place with no 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?

For a simple read-only log tail tool with a fully documented schema and no output schema, the description is sufficiently complete. It covers the core function and default behavior. Additional details like output format or error cases would be nice but are not critical 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 100%, with each parameter already documented (e.g., lines default 100, buildId defaults to latest). The description does not add meaning beyond what the schema provides; it merely restates the defaults. This matches the baseline for full schema coverage.

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

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

The description clearly states the action ('Return the last N lines of a build log') with a specific verb and resource. It distinguishes itself from sibling tools like trigger_build or build_status by focusing on log content, making its 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 context is clear: it is for reading log lines from a build. It mentions the default behavior when buildId is omitted, which helps agents know when to use it. However, it does not explicitly contrast with sibling tools or state when not to use it, so it stops 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?

With no annotations provided, the description carries the full burden. It discloses the required write scope, the return format (jobId/status/message), and the special case of skipped builds with skipReason. It also implies async behavior via jobId. While it doesn't detail all failure modes, it covers the most relevant behavioral aspects.

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 packed sentence with no wasted words. It leads with the action, then prerequisites, then return shape, and finally the skip case. Every clause 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 tool with 2 parameters and no output schema, the description sufficiently explains the return values and the skip scenario. It lacks detailed error handling info, but that is not essential given the return structure and permission note. It is complete enough for correct invocation.

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

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

Schema coverage is 100%, so both parameters are already described in the input schema. The description merely repeats the platform examples without adding new meaning, such as relationships or format constraints. Baseline 3 applies because the schema does the heavy lifting.

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 'Trigger a CI/CD build for a project on a platform' – a specific verb and resource. It distinguishes from siblings like build_status by focusing on initiation rather than status. The examples of platforms add context without confusion.

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 its use (to start a build) and provides a prerequisite ('Requires an API token with the write scope'), but it does not explicitly mention alternatives or when not to use it. Given sibling names like build_status, the usage is inferable but not stated.

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