Chromium CodeSearch MCP

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting different resources (e.g., Chromium vs. PDFium, file operations vs. issue tracking vs. CI builds). However, there is some overlap between Chromium and PDFium Gerrit tools (e.g., get_gerrit_cl_comments vs. get_pdfium_gerrit_cl_comments) that could cause confusion if the domain isn't clearly specified in queries. The descriptions help differentiate, but the parallel structures create minor ambiguity.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern with clear prefixes (e.g., get_, list_, search_, find_). All tools use snake_case uniformly, and the naming conventions are predictable across the set, making it easy to understand each tool's function at a glance.
Tool Count3/5
With 23 tools, the count feels heavy for a code search server, though it covers multiple domains (Chromium source, Gerrit, PDFium, CI). It's borderline because the scope is broad but not excessive; however, the duplication between Chromium and PDFium tools inflates the count without adding unique functionality, making it slightly over-scoped.
Completeness5/5
The tool set provides comprehensive coverage for Chromium development workflows, including code search, file access, issue tracking, Gerrit CL management (status, diffs, comments), CI error analysis, and reviewer suggestions. There are no obvious gaps; it supports full lifecycle operations from code exploration to patch review and debugging.
Average 3.2/5 across 23 of 23 tools scored.
See the Tool Scores section below for per-tool breakdowns.
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
Tools from this server were used 10 times in the last 30 days.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 describes the search method ('searching up the directory tree') but omits critical details such as the return format (e.g., list of OWNERS file paths or contents), error handling for invalid paths, or performance considerations like rate limits. This is a significant gap for a tool with no structured safety hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Find OWNERS files') and method ('searching up the directory tree'), with no redundant or wasted words. It's appropriately sized for a simple tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., OWNERS file contents or paths), error conditions, or how it integrates with the Chromium codebase context. For a tool with no structured output, more behavioral and result details are needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'file_path' parameter well-documented in the schema itself. The description adds minimal value beyond the schema by implying the path is used to traverse directories, but it doesn't provide additional semantics like path format constraints or examples beyond what's already in the schema. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Find OWNERS files') and the target resource ('for a given file path in Chromium source code'), with the method 'by searching up the directory tree' providing additional specificity. It distinguishes from siblings like 'list_chromium_folder' or 'get_chromium_file' by focusing on ownership metadata rather than file contents or listings, 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'suggest_reviewers_for_cl' or 'get_gerrit_cl_status', which might relate to code ownership. It implies usage for finding ownership information in Chromium but lacks explicit context, prerequisites, or exclusions, leaving the agent to infer applicability.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 finding 'definition, references, and usage' but does not specify output format, pagination, rate limits, authentication needs, or error handling. For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. It earns its place by clearly stating what the tool does, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a symbol search tool with no annotations and no output schema, the description is incomplete. It lacks details on return values, behavioral traits, and differentiation from siblings. While concise, it does not provide enough context for an agent to fully understand how to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting both parameters ('symbol' and 'file_path'). The description adds no additional meaning beyond what the schema provides, such as examples or edge cases. With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('find') and resource ('symbol definition, references, and usage in Chromium source'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'search_chromium_code' or 'get_chromium_file', which might have overlapping functionality, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'search_chromium_code' for broader searches or 'get_chromium_file' for file-specific content. It lacks explicit when/when-not instructions or named alternatives, leaving usage context implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 what the tool does but doesn't mention critical behaviors like whether it requires authentication, rate limits, error handling (e.g., for invalid file paths), or the format of returned content (e.g., plain text, structured data). This leaves significant gaps for an agent to understand how to use it effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that front-loads the core purpose without any wasted words. It efficiently communicates the essential action and resource, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral aspects like error conditions, return format, or usage context relative to siblings. For a tool that retrieves file contents—potentially involving large data or specific source structures—more guidance is needed to ensure proper agent operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond implying file retrieval, which is redundant with the schema. This meets the baseline of 3, as the schema does the heavy lifting without needing extra explanation from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get contents') and resource ('specific file from Chromium source'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_chromium_folder' or 'get_gerrit_patchset_file', which might also retrieve file contents but from different contexts or with different scopes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't clarify if this is for raw source files versus patchset files (like 'get_gerrit_patchset_file') or when to prefer 'search_chromium_code' for broader queries. The description lacks any context about prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it 'Get details' but doesn't specify what details are returned, potential errors (e.g., for invalid IDs), rate limits, authentication needs, or whether it's a read-only operation. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Get details') and resource. There's no wasted wording, and it directly communicates the essential information without unnecessary elaboration, 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what 'details' are returned, potential response formats, error conditions, or how it differs from similar tools. For a tool with no structured behavioral data, the description should provide more context to compensate, but it falls short.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'issue_id' fully documented in the schema as accepting an ID or URL. The description doesn't add any meaningful information beyond what the schema provides—it doesn't clarify format nuances, examples beyond the schema's, or edge cases. With high schema coverage, a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get details') and resource ('specific Chromium issue/bug'), making the purpose immediately understandable. It specifies the source ('from issues.chromium.org'), which adds useful context. However, it doesn't explicitly differentiate from sibling tools like 'search_chromium_issues', which might retrieve multiple issues rather than a single one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_chromium_issues' for finding multiple issues or other tools for different Chromium resources. There's no indication of prerequisites, constraints, or typical use cases beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, the description doesn't mention authentication requirements, rate limits, pagination behavior, error conditions, or what format the comments are returned in. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for what it communicates and is front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the return value looks like (comment format, structure), doesn't mention authentication or rate limiting considerations, and provides no usage context relative to sibling tools. The description alone doesn't provide enough information for confident tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter semantics beyond what's already in the schema descriptions (e.g., CL number format, patchset optionality, include_resolved default). This meets the baseline expectation when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get review comments') and target resource ('for a Chromium Gerrit CL patchset'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_gerrit_cl_status' or 'get_gerrit_cl_diff' that also operate on Gerrit CLs, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for Gerrit CLs (e.g., get_gerrit_cl_status, get_gerrit_cl_diff, get_gerrit_cl_bot_errors), there's no indication of when this specific comment-retrieval tool is appropriate versus other CL-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While 'Get' implies a read-only operation, the description doesn't specify what 'status and test results' includes (e.g., build status, test outcomes, timing), whether it requires authentication, rate limits, or how results are formatted. This leaves significant gaps for an agent to understand the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence ('Get status and test results for a Chromium Gerrit CL') directly contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of Gerrit CL status (which can include multiple test types and build outcomes), no annotations, and no output schema, the description is insufficient. It doesn't explain what 'status and test results' entails, how results are structured, or potential limitations, leaving the agent with incomplete context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'cl_number' well-documented in the schema (accepting CL numbers or full URLs). The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 for adequate coverage without extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get status and test results') and the resource ('for a Chromium Gerrit CL'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_gerrit_cl_trybot_status' or 'get_gerrit_cl_bot_errors', which likely provide overlapping or related information about Gerrit CLs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools related to Gerrit CLs (e.g., get_gerrit_cl_trybot_status, get_gerrit_cl_bot_errors, get_gerrit_cl_comments), there's no indication of what specific 'status and test results' means or how it differs from other tools that might provide similar or complementary data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions retrieving 'status and test results' but doesn't specify what format these results come in, whether there are rate limits, authentication requirements, or what happens with invalid CL numbers. This leaves significant gaps for an agent to understand the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple lookup tool and gets straight to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'status and test results' actually means, what format they come in, or what the agent can expect as output. Given the lack of structured information elsewhere, the description should provide more complete context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, thoroughly documenting the single parameter with examples. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation without adding extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get status and test results') and the resource ('for a PDFium Gerrit CL'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from its sibling 'get_gerrit_cl_status' beyond mentioning 'PDFium' in the name, leaving some ambiguity about when to use this versus the more general version.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives like 'get_gerrit_cl_status' or 'get_pdfium_gerrit_cl_trybot_status'. The description simply states what it does without indicating context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation (implied by 'Get'), authentication requirements, rate limits, error conditions, or what the output format looks like (e.g., raw text, structured data). The phrase 'for making code changes' hints at a use case but doesn't describe tool behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured by separating the 'for making code changes' context, but it avoids redundancy and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a tool with 3 parameters. It doesn't explain what the output contains (e.g., file content, metadata), error handling, or important behavioral aspects like whether it retrieves raw source or processed content. The context 'for making code changes' is helpful but insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing clear documentation for all three parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., doesn't explain file_path conventions or patchset defaults further). This meets the baseline of 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get the content of a specific file') and resource ('from a PDFium Gerrit patchset'), with the purpose 'for making code changes' adding context. It distinguishes from general 'get_gerrit_patchset_file' by specifying PDFium, but doesn't explicitly differentiate from sibling 'get_pdfium_gerrit_cl_diff' which might also provide file content in diff form.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_pdfium_gerrit_cl_diff' (which might show file changes) or 'get_chromium_file' (for non-PDFium files). The phrase 'for making code changes' implies a context but doesn't specify prerequisites, exclusions, or clear alternatives among the many sibling Gerrit/Chromium tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 search syntax but doesn't describe key behaviors such as rate limits, authentication needs, result format, pagination, or error handling. For a search tool with 7 parameters and no output schema, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose and method without any fluff. It's front-loaded with essential information and wastes no words, 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain the return format, result limitations, error conditions, or how it differs from sibling tools. Without annotations or output schema, the agent lacks critical context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly with examples and defaults. The description adds no additional parameter semantics beyond what's in the schema, such as explaining interactions between parameters or advanced usage tips. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for code in the Chromium source repository using Google's official Code Search syntax.' It specifies the verb ('Search'), resource ('code in the Chromium source repository'), and method ('using Google's official Code Search syntax'). However, it doesn't explicitly differentiate from sibling tools like 'search_chromium_commits' or 'search_chromium_issues,' which reduces the score from a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'find_chromium_symbol' or 'search_chromium_commits,' nor does it specify any prerequisites, exclusions, or contextual cues for selection. This leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It mentions the API used (Gitiles) but doesn't describe rate limits, authentication needs, error conditions, response format, or pagination behavior. For a search tool with 5 parameters, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the search returns, how results are structured, any limitations of the Gitiles API, or error handling. The description alone is insufficient for an agent to understand the full context of using this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema. This meets the baseline of 3 for high schema coverage, but doesn't provide extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Search') and resource ('commit messages and metadata in the Chromium repository') with the specific method ('using Gitiles API'). It distinguishes from some siblings like 'search_chromium_code' or 'search_chromium_issues' by specifying the search target is commits, but doesn't explicitly differentiate from all sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'search_chromium_code' or 'search_chromium_issues', nor does it provide any context about prerequisites, limitations, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'for making code changes', hinting at a read operation for editing purposes, but fails to disclose critical behavioral traits such as authentication needs, rate limits, error handling, or the format of the returned content. This is inadequate for a tool with no 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is minimal but covers the basic purpose. However, for a tool that retrieves file content, it lacks details on return format, error cases, or integration with sibling tools, leaving gaps in context. It is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents the parameters. The description does not add any semantic details beyond what the schema provides, such as explaining the relationship between parameters or usage nuances. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'content of a specific file from a Gerrit patchset', making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get_pdfium_gerrit_patchset_file' or 'get_gerrit_cl_diff', which might have overlapping contexts, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes 'for making code changes', which implies a context of code modification, but it lacks explicit guidance on when to use this tool versus alternatives like 'get_chromium_file' or 'get_gerrit_cl_diff'. No exclusions or clear alternatives are provided, leaving usage vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions retrieving comments but doesn't specify whether this is a read-only operation, potential rate limits, authentication needs, or what the output format looks like (e.g., JSON structure). This leaves gaps in understanding the tool's behavior and constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the core purpose without unnecessary words. It uses clear terminology ('review comments', 'PDFium Gerrit CL patchset') and avoids redundancy, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavioral traits, usage context, and output format. Without annotations or an output schema, more information would be helpful for full contextual understanding, but it's not entirely incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all three parameters (cl_number, patchset, include_resolved) with their types, optionality, and defaults. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for adequate but not enhanced parameter clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('review comments for a PDFium Gerrit CL patchset'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from its sibling 'get_gerrit_cl_comments', which appears to be a more general version, leaving some ambiguity about when to use this PDFium-specific variant.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_gerrit_cl_comments' or other sibling tools. It lacks context about prerequisites, such as needing access to PDFium Gerrit, and doesn't mention any exclusions or specific scenarios where this tool is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states what the tool does but doesn't disclose behavioral traits like whether it returns recursive listings, pagination behavior, error handling for invalid paths, format of returned data, or performance characteristics. The description is minimal and lacks operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that clearly states the tool's purpose. It's appropriately sized for a simple listing tool with one parameter. No wasted words or unnecessary elaboration - every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only listing tool with good schema coverage but no output schema, the description is minimally adequate. It covers the basic purpose but lacks context about return format, error conditions, or relationship to sibling tools. Without annotations or output schema, more behavioral context would be helpful for an agent to use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single parameter 'folder_path' well-documented in the schema. The description doesn't add any parameter semantics beyond what's in the schema - it mentions 'specific directory' which aligns with the schema but provides no additional context about path format constraints, relative vs absolute paths, or special directory handling.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resources 'files and folders' with the specific context 'in a specific directory of the Chromium source tree'. It distinguishes from general file listing tools by specifying the Chromium source tree context, but doesn't explicitly differentiate from sibling tools like 'get_chromium_file' or 'search_chromium_code' which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate (e.g., for browsing directory contents) versus when to use siblings like 'get_chromium_file' (for file contents) or 'search_chromium_code' (for searching within files). No exclusions or prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool retrieves diff/changes but doesn't describe the return format (e.g., unified diff, JSON), pagination, rate limits, authentication needs, or error handling. For a tool with 3 parameters and no output schema, this leaves significant behavioral gaps, though it correctly indicates a read operation without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get the diff/changes for a Chromium Gerrit CL patchset') and ends with the specific goal ('to understand what code was modified'). There is zero waste, and every word earns its place, 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on the return format, error conditions, rate limits, or how the diff is presented (e.g., text vs. structured data). For a tool that retrieves code changes, this omission is significant, as the agent won't know what to expect from the output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain format of the diff output or interactions between parameters). This meets the baseline of 3 when schema coverage is high, but doesn't compensate with extra insights.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get the diff/changes') and resource ('for a Chromium Gerrit CL patchset'), with the specific purpose 'to understand what code was modified'. It distinguishes from siblings like get_gerrit_cl_status or get_gerrit_cl_comments by focusing on code changes rather than status or comments. However, it doesn't explicitly differentiate from get_pdfium_gerrit_cl_diff, which serves a similar purpose for a different codebase.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing to understand code modifications in a Chromium Gerrit CL, but doesn't provide explicit guidance on when to use this tool versus alternatives. For example, it doesn't mention when to choose this over get_gerrit_patchset_file (which might get specific file content) or search_chromium_commits (which searches across commits). The context is clear but lacks explicit alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'full-text search' but lacks details on rate limits, authentication needs, result format, pagination behavior beyond the schema's 'start_index', or whether this is a read-only operation. The description is minimal and doesn't compensate for the missing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without wasted words. Every part earns its place by specifying the action, target, and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a search tool with 3 parameters. It lacks details on behavioral traits (e.g., rate limits, result structure) and doesn't explain return values, leaving significant gaps for an AI agent to understand the tool's full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents parameters. The description adds no additional meaning beyond implying the 'query' parameter searches across multiple fields, which is already covered in the schema's description. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('search') and resource ('issues in the Chromium issue tracker') with scope ('full-text search across titles, descriptions, and metadata'). It distinguishes from some siblings like 'get_chromium_issue' (which likely retrieves a specific issue) but doesn't explicitly differentiate from 'search_chromium_code' or 'search_chromium_commits' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for searching issues via text queries, but provides no explicit guidance on when to use this tool versus alternatives like 'get_chromium_issue' (for specific issues) or other search tools. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves diffs but doesn't mention critical details like whether it's a read-only operation, potential rate limits, authentication needs, or what the output format looks like (e.g., raw diff text, structured data). For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the tool's purpose without unnecessary words. It's front-loaded with the core action ('Get the diff/changes') and includes the rationale ('to understand what code was modified'), making it easy to parse. Every part of the sentence earns its place, resulting in an optimal balance of clarity and brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is adequate but incomplete. It explains what the tool does but lacks details on behavioral aspects (e.g., safety, output format) and doesn't leverage context from siblings. For a tool focused on code analysis, more guidance on usage scenarios or output interpretation would enhance completeness, but it meets the minimum viable threshold.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all three parameters (cl_number, patchset, file_path) with their types and optionality. The description adds no additional parameter semantics beyond what's in the schema, such as format examples or usage tips. With high schema coverage, the baseline score of 3 is appropriate, as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the diff/changes for a PDFium Gerrit CL patchset to understand what code was modified.' It specifies the verb ('get'), resource ('diff/changes'), and scope ('PDFium Gerrit CL patchset'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_gerrit_cl_diff' or 'get_pdfium_gerrit_patchset_file', which is why it doesn't reach a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('to understand what code was modified'), suggesting it's for analyzing code changes. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_gerrit_cl_diff' (for non-PDFium Gerrit) or 'get_pdfium_gerrit_patchset_file' (for specific file content). The usage is clear but lacks sibling differentiation and exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 adds some context about authentication requirements ('requires authentication cookie'), which is useful. However, it doesn't describe other behavioral traits like rate limits, pagination, error handling, or what the return format looks like (no output schema exists).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and adds authentication context. There's no wasted text, though it could be slightly more structured with separate usage notes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters, no annotations, and no output schema, the description is moderately complete. It covers authentication needs but lacks details on return values, error cases, or behavioral constraints. For a list operation with authentication requirements, more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema (e.g., it doesn't explain query syntax beyond examples in schema). Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('Gerrit CLs from Chromium dashboard'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_pdfium_gerrit_cls' or 'get_gerrit_cl_status', which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'requires authentication cookie', but doesn't provide explicit guidance on when to use this tool versus alternatives like 'list_pdfium_gerrit_cls' or 'search_chromium_commits'. It lacks clear when/when-not instructions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While it mentions what information is returned ('detailed try-bot status... individual bot results and pass/fail counts'), it doesn't describe important behavioral aspects like whether this is a read-only operation, potential rate limits, authentication requirements, error conditions, or response format. The description provides basic functionality but lacks operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and includes specific details about what information is returned. Every word contributes value, with no redundant or unnecessary information. The structure is clear and direct.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's no output schema and no annotations, the description provides adequate basic functionality but lacks important contextual information. For a tool with 3 parameters that returns detailed status information, the description should ideally mention something about the return format or structure. However, it does clearly state what information will be included in the response ('individual bot results and pass/fail counts'), which provides some output context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are well-documented in the schema itself. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no parameter information in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get detailed try-bot status') and resource ('for a Chromium Gerrit CL'), including the scope of information returned ('individual bot results and pass/fail counts'). It distinguishes this tool from siblings like 'get_gerrit_cl_status' by focusing specifically on try-bot status rather than general CL status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the resource specification ('Chromium Gerrit CL'), but doesn't explicitly state when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_gerrit_cl_bot_errors' or 'get_ci_build_errors' that might overlap in functionality, nor does it provide exclusion criteria or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'detailed try-bot status' and 'individual bot results and pass/fail counts', which gives some behavioral insight, but doesn't disclose critical traits like whether this is a read-only operation, rate limits, authentication needs, error handling, or response format. For a tool with no annotations, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place: it specifies the action, resource, and key details (individual bot results, pass/fail counts) in a compact format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose but lacks completeness for a tool with 3 parameters. It doesn't cover behavioral aspects like safety, response structure, or error conditions. While concise, it's insufficient for full contextual understanding without structured support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all three parameters (cl_number, patchset, failed_only). The description adds no additional parameter semantics beyond what's in the schema, such as format examples or usage nuances. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get detailed try-bot status'), resource ('for a PDFium Gerrit CL'), and scope ('including individual bot results and pass/fail counts'). It distinguishes from sibling tools like 'get_gerrit_cl_trybot_status' by specifying PDFium context and from 'get_pdfium_gerrit_cl_status' by focusing on try-bot details rather than general CL status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (PDFium Gerrit CL try-bot status) but doesn't explicitly state when to use this tool versus alternatives like 'get_gerrit_cl_trybot_status' or 'get_pdfium_gerrit_cl_status'. It provides no guidance on prerequisites, exclusions, or specific scenarios where this tool is preferred over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 adds value by specifying the authentication requirement and hinting at the source ('PDFium dashboard'), but lacks details on rate limits, error handling, or output format. It doesn't contradict any annotations (none exist), but leaves gaps in behavioral context for a tool with authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and includes essential context (authentication requirement). Every word earns its place with zero waste, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is minimally complete for a listing tool with authentication. It covers the what and a key how (auth), but lacks details on output structure, error cases, or performance limits. For a tool with 3 parameters and authentication needs, this leaves the agent with incomplete operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all three parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't elaborate on query syntax or cookie format). This meets the baseline of 3 when the schema does the heavy lifting, but doesn't compensate with extra insights.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('PDFium Gerrit CLs from PDFium dashboard'), making the purpose immediately understandable. It distinguishes from siblings like 'list_gerrit_cls' by specifying 'PDFium' scope, though it doesn't explicitly contrast with other PDFium tools like 'get_pdfium_gerrit_cl_status'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'requires authentication cookie', suggesting this tool is for authenticated access to PDFium Gerrit. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'list_gerrit_cls' (general) or other PDFium-specific query tools, leaving the agent to infer based on the PDFium focus.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the tool's purpose (retrieving error details) and output format (stack traces, test failures), but doesn't mention behavioral aspects like rate limits, authentication requirements, error handling, or what happens when no errors exist. It adds some context about what gets returned but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that are front-loaded with the core purpose. Every word earns its place: first sentence states what the tool does and what it includes, second sentence explains the diagnostic purpose. No wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, no annotations, and no output schema, the description provides adequate purpose and context but lacks important operational details. It explains what the tool retrieves but doesn't describe the return format, error conditions, or limitations. Given the complexity of debugging test failures, more behavioral context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. It mentions the general purpose ('diagnose why tests failed') but provides no additional syntax, format, or usage details for parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get detailed error messages with stack traces'), target resource ('failed try-bots for a Chromium Gerrit CL'), and scope ('actual test failures, assertion errors, and full stack traces'). It distinguishes from siblings like 'get_gerrit_cl_trybot_status' by focusing specifically on error details rather than general status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('to diagnose why tests failed'), but doesn't explicitly state when not to use it or name specific alternatives. It implies usage for debugging test failures rather than general status checking, which is helpful but not fully explicit about alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key behavioral traits: it analyzes OWNERS files and recent commit activity, suggests a minimal set of reviewers, and ranks them by coverage and activity. However, it lacks details on performance characteristics (e.g., timeouts), error handling, or output format, which would be helpful for an agent to anticipate results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and efficiently structured in two sentences: the first states the core purpose and methods, and the second elaborates on the ranking criteria. Every sentence adds essential information without redundancy, making it easy for an agent to quickly grasp the tool's functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (analyzing CLs and suggesting reviewers) and the absence of both annotations and an output schema, the description does a good job of covering the core behavior and purpose. However, it lacks details on the output format (e.g., what data is returned) and potential limitations (e.g., handling of large CLs), which would improve completeness for agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, providing clear details for all 5 parameters. The description adds minimal value beyond the schema, as it does not explain parameter interactions or provide additional context (e.g., how 'fast' mode affects accuracy). With high schema coverage, the baseline score of 3 is appropriate, as the description does not significantly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('find', 'analyzes', 'suggest') and resources ('optimal reviewers for a Chromium CL'), explicitly mentioning the analysis methods (OWNERS files and recent commit activity) and the goal (minimal set of reviewers covering all changed files). It distinguishes itself from sibling tools like 'get_gerrit_cl_status' or 'search_chromium_commits' by focusing on reviewer recommendation rather than status checking or searching.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'for a Chromium CL' and mentions analysis methods, but it does not provide explicit guidance on when to use this tool versus alternatives like 'find_chromium_owners_file' or 'get_gerrit_cl_comments'. No exclusions or prerequisites are stated, leaving the agent to infer usage based on the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 tool's behavior by specifying what it returns ('detailed error messages with stack traces', 'test failures, assertion errors'), which is helpful. However, it doesn't mention potential limitations like authentication needs, rate limits, error handling, or the format/structure of the returned data, leaving gaps for a mutation-free but data-rich operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that are front-loaded with the core purpose and follow with specific details. Every word earns its place by adding clarity about what the tool retrieves, with no redundant or vague phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, no output schema, no annotations), the description is reasonably complete. It explains what the tool does and what it returns, but lacks details on output format, error cases, or system constraints. For a read-only tool with good schema coverage, this is sufficient but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents the single parameter 'build_url' with examples. The description adds value by clarifying the parameter's purpose ('from a specific CI build URL') and implying it accepts various URL formats or IDs, but doesn't provide additional syntax or format details beyond the schema. With only one parameter, a baseline of 4 is appropriate as the description complements the schema adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get detailed error messages with stack traces') and resource ('from a specific CI build URL'), distinguishing it from sibling tools like get_gerrit_cl_bot_errors or get_gerrit_cl_status by focusing on CI build errors rather than Gerrit CL issues. It specifies the exact content returned: 'actual test failures, assertion errors, and complete stack traces'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when you need detailed error information from a CI build. It doesn't explicitly state when not to use it or name alternatives, but the specificity of 'CI build URL' and the sibling tool list (which includes Gerrit-focused error tools) imply it's for CI builds rather than Gerrit CLs or other contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![chromium-helper MCP server](https://glama.ai/mcp/servers/hjanuschka/chromium-helper/badges/card.svg)](https://glama.ai/mcp/servers/hjanuschka/chromium-helper)

Score Badge

Copy to your README.md:

[![chromium-helper MCP server](https://glama.ai/mcp/servers/hjanuschka/chromium-helper/badges/score.svg)](https://glama.ai/mcp/servers/hjanuschka/chromium-helper)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/hjanuschka/chromium-helper'

If you have feedback or need assistance with the MCP directory API, please join our Discord server