Comet MCP Server

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 wait_after behavior but does not disclose potential side effects like navigation, triggered events, or behavior on missing/unmatched selectors. For a click action, this is a meaningful 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 compact and front-loaded: one clear purpose sentence followed by a terse Args list. Every sentence earns its place with no fluff or repetition.

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 (2 params, 1 required) and the presence of an output schema, the description is mostly complete for successful invocation. It covers both parameters well, though it omits side-effect/error context that would round out the no-annotation situation.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining that selector accepts CSS selectors or 'text=Something' for text matching, and that wait_after is the seconds to wait after clicking. This adds significant meaning beyond the bare schema types.

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 action ('Click') on a specific resource ('an element on the current Comet page'), making the tool's purpose immediately clear. It is distinct from sibling tools like comet_type (input) and comet_evaluate (script execution).

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 within the current Comet page and gives selector syntax, but it does not explicitly state when to use this tool instead of alternatives like comet_type or comet_wait. There are no exclusions, conditions, or 'use X instead' guidance.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It reveals an important side effect: 'Auto-launches Comet if needed,' which is valuable context beyond the empty schema. It does not describe the return format or failure states, but the output schema likely covers that, and the auto-launch detail addresses the main behavioral surprise.

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

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

Two short sentences with zero filler. The core action is front-loaded, and the usage ordering instruction is placed in the second sentence, keeping it compact and easy to parse. Every word contributes necessary information.

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

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

Given the tool has no parameters and an output schema is present, the description covers the essential contextual needs: it establishes the tool's role as a prerequisite and discloses auto-launch behavior. It could mention idempotency or what 'connected' means, but with the sibling context and output schema, an agent has enough to call this tool correctly.

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

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

The input schema is an empty object, meaning there are no parameters to document. The description correctly adds no param details since none exist. The baseline of 4 for a zero-parameter tool applies, and the description does not need to compensate for any schema gaps.

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 action ('Connect') and a clear resource ('the Comet browser via CDP'), and distinguishes this tool from its siblings by establishing it as the mandatory first step. An agent can immediately understand this is the connection/setup tool, not an action like navigate or click.

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 explicit instruction 'Call this before using any other comet tool' provides unambiguous usage ordering. It makes clear this tool is a prerequisite, and all sibling comet tools are the contexts where this should be used. No alternative connection method is needed because this is the singular entry point.

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 must fully carry behavioral disclosure. It only restates the evaluation action and does not mention possible page mutation, navigation side effects, error behavior, or whether the expression result is returned. Arbitrary JavaScript execution can have significant side effects, so this gap matters.

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

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

The description is compact and front-loads the core purpose in the first sentence. The Args block partially repeats the purpose, but it is short, conventional, and directly documents the parameter.

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

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

The tool has only one parameter and an output schema, so return-value documentation is not strictly needed. However, the description omits behavioral caveats and usage prerequisites for an operation that can execute arbitrary code in the page, leaving an agent with enough to call the tool but not enough to understand its full impact.

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

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

Schema description coverage is 0%, so the description must define the sole parameter. It adds that 'expression' is a JavaScript expression to evaluate in page context, which is minimal but sufficient for a single string parameter. It provides no examples, syntax expectations, or async/return-value details.

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

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

The description uses a specific verb ('Evaluate') and identifies the resource clearly: 'a JavaScript expression in the current Comet page.' It is immediately clear what the tool does and is distinct from sibling tools like click, type, and read_page, though it does not explicitly name or contrast them.

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

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

There is no guidance about when to use this tool versus alternatives, when not to use it, or prerequisites such as an active page connection. The phrase 'current Comet page' implies a prior navigation step but does not state what must be true before evaluation.

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 bears the full burden of behavioral disclosure, but it only states the navigation action and lists wait conditions. It does not disclose side effects such as replacing the current page, altering history, or whether a connection to Comet is required.

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

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

The description is short, front-loaded with the primary purpose, and the arguments block is compact. The wait_for enumeration earns its place, though the url line is somewhat redundant with the parameter name.

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 low-complexity tool with two parameters and an output schema, the essential calling information is present. However, the lack of usage context and side-effect disclosure leaves an agent without enough behavioral context to anticipate the tool's impact on the browsing session.

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

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

Schema description coverage is 0%, so the description must compensate. It gives url a clear role and enumerates the accepted wait_for values, adding real meaning beyond the schema. It stops short of specifying URL format requirements, but it covers both parameters adequately.

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

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

The description uses a specific verb and resource ('Navigate Comet to a specific URL') and is clearly distinct from sibling tools that screenshot, search, read, click, type, or evaluate. However, it does not explicitly differentiate itself from a similar navigation-related sibling, so it stops 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.

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or conditions that would make comet_search or comet_read_page more appropriate instead.

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

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

With no annotations, the description carries the full burden. 'Read' implies a non-mutating operation, and the args disclose default behavior for links and truncation. However, it does not explicitly state read-only/no-side-effect guarantees or behavior on empty/unloaded pages.

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 purpose is front-loaded in the first sentence, followed by a compact Args block with no filler. Every sentence contributes information.

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

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

For a simple read tool with no required parameters and an output schema present, the description covers the essential behavior and all parameters. It is slightly incomplete in not mentioning usage boundaries or alternatives, but these are mainly covered by the usage-guidelines gap.

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

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

The input schema has 0% description coverage, so the description must compensate. It provides meaningful semantics for all three parameters: selector is a CSS selector for specific content, include_links controls href inclusion, and max_length caps returned characters.

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 first sentence states a specific action and resource: 'Read the text content of the current page in Comet.' This clearly distinguishes the tool from visual/capture siblings like comet_screenshot, but it does not explicitly differentiate from similarly read-oriented siblings such as comet_search or comet_evaluate.

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

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

The description gives no guidance about when to choose this tool over alternatives, no exclusions, and no mention of prerequisites. The Args section only explains parameter usage, not tool selection.

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

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

With no annotations, the description carries the behavioral burden. It clearly discloses the return format (base64 PNG) and the effect of the full_page flag, which is the key behavioral toggle. It omits minor details like image dimensions or load-wait behavior, but the core behavior is transparent.

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

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

Two crisp sentences with an args section. The core action and return type are front-loaded, and every sentence earns its place without extraneous detail.

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

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

For a simple tool with one optional parameter and a stated return format, the description is fully sufficient to invoke it correctly. It covers the only toggle, the target ('current Comet page'), and what the caller receives.

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?

Although the schema's property has no description, the tool description manually documents full_page as 'Whether to capture the full scrollable page.' This adds the exact meaning an agent needs beyond the schema's title and default value.

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 and resource: take a screenshot of the current Comet page. The return format (base64 PNG) further clarifies the tool's role and distinguishes it from siblings like comet_read_page, which would read page content.

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

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

Usage is implied by the action itself: use this when a visual capture of the current page is needed. However, it does not explicitly contrast with alternatives such as comet_read_page or state when not to use the tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the core mechanism (URL-based navigation, waiting time for AI generation, and result extraction) and the mode values. However, it does not mention side effects, failure behavior, external site dependencies, or whether a prior browser connection is required.

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 front-loaded with a one-line purpose, followed by a compact mechanism note and a terse Args list. Every sentence contributes useful information 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?

An output schema exists, so return-value documentation is not required. The core operation and all parameters are well covered. A minor gap is that prerequisites such as whether an active browser connection via comet_connect must already be established are not stated, but this does not substantially block correct invocation.

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

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

Schema description coverage is 0%, but the description compensates fully by documenting all three parameters: query, wait_seconds, and mode, including the exact mode values ('search' or 'research'). This adds real semantic meaning beyond the bare schema.

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

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

The description opens with a specific verb-resource pair: 'Search the web using Perplexity via Comet,' and then explains the exact mechanism: navigating to perplexity.ai/search?q=QUERY and extracting the AI-generated results. This clearly distinguishes it from sibling tools like comet_navigate or comet_screenshot.

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

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

The description provides clear context: use this tool when an AI-generated web search result is needed, and it explicitly notes that no CSS selectors are required. However, it does not name specific sibling alternatives or state conditions for 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does provide meaningful detail by listing detection categories: hidden text, CSS-invisible elements, injection attempts, and suspicious content. However, it does not state whether the scan is read-only, whether it executes scripts, or whether it makes network requests—relevant context for a security tool.

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

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

A single sentence that front-loads the action and object ('Deep security scan of current page') and then adds concrete detail. There is no filler and no repetition of schema information.

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

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

For a no-argument tool, the description names the page under inspection and the main detection axes, and an output schema exists to cover return values. It falls just short of full completeness because it omits any statement about side effects, required page state, or whether a prior navigation is necessary.

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 is empty with 0 parameters and effectively 100% coverage, so there is no parameter documentation burden. The baseline for zero-parameter tools is 4, and the description correctly avoids introducing parameter-specific claims.

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 operation ('Deep security scan') on a specific resource ('current page') and enumerates concrete detection targets. None of the sibling tools overlap with this function, so an agent can select it unambiguously.

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?

Usage is implied: scan the current page when security inspection is needed. However, there are no explicit when-to-use or when-not-to-use conditions, and no alternative tools are named. The moderate gap is acceptable for a zero-parameter tool with a unique 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the available tab actions and their parameter associations, but does not mention side effects, preconditions (e.g., a connected browser or existing tab), or failure behavior. This is adequate but not rich.

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

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

The description is compact and front-loaded with the tool's purpose, followed by a clean, scannable Args block. Every line adds specific semantic value, with no filler or repetition.

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

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

The description completely covers the parameters and action vocabulary, and an output schema exists for return values. However, it does not mention prerequisites such as whether a browser connection is already required, nor what happens with invalid indices or missing URLs for new tabs. This leaves minor but real gaps.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining the meaning and allowed values of action, the 0-based role of tab_index for switch/close, and the role of url for the new action. Every parameter receives meaningful semantic context absent from the schema.

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

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

The description clearly states the resource ('tabs in the Comet browser') and enumerates the core operations: list, new, switch, close. This distinguishes it from sibling tools like comet_navigate, comet_read_page, and comet_screenshot, which are page-level or browser-level operations.

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

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

The description provides clear context: an agent should use this tool whenever it needs to manipulate browser tabs. It does not explicitly name alternatives or when-not conditions, so it stops short of a 5, but the action list leaves little ambiguity about its intended use.

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

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

With no annotations, the description carries the behavioral disclosure burden. It transparently mentions the optional press_enter and clear_first behaviors, but it does not state whether the tool waits for the element, focuses the field, fires real key events, or what happens when the selector is not found. Core behavior is clear, but edge behavior is not disclosed.

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 purpose statement is front-loaded, and the Args block directly lists all four parameters with no filler or repeated information. Every sentence adds value, and the structure is easy to scan.

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

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

The description names the target context ('current Comet page'), explains all parameters, and the presence of an output schema means return values do not need to be detailed. It is complete enough for a simple typing tool, though explicit guidance about when to choose it over siblings is missing.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It provides a concise semantic line for each of the four parameters, including the meaning of the boolean flags. This compensates well for the empty schema, though it does not go deeper into selector syntax or input validation.

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 action ('Type text into an input field') and scopes it to 'the current Comet page,' making the tool's purpose immediately clear. This also distinguishes it from sibling tools like comet_click and comet_evaluate without needing to inspect their schemas.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as comet_click or comet_evaluate. It provides context about the current page but no exclusions, conditions, or routing hints, so an agent is left to infer when this is the appropriate choice.

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 full burden of behavioral disclosure. It only says 'wait' and does not explain timeout behavior, whether it polls for visibility, what happens when both selector and seconds are provided, or whether it blocks. For an agent deciding how to handle a wait failure, this is a significant gap.

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

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

The description is maximally economical: one summary sentence followed by a structured two-entry Args list. There is no filler or repetition, and the core purpose is front-loaded in the first sentence.

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

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

The tool is simple and has an output schema, so some leanness is acceptable. However, the description lacks important context such as expected usage relative to sibling actions, what happens if the element never appears, and the effect of passing neither argument. These are clear gaps for a tool with no annotations.

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 zero description coverage, so the Args section is the only source of parameter meaning. It explains that selector is a CSS selector and seconds is a fixed duration, covering both parameters effectively. It stops short of clarifying interaction or precedence when both are supplied, but for a two-parameter tool this is adequate.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Wait for a specific element or a fixed duration.' It also distinguishes two modes of operation, but it does not explicitly differentiate itself from sibling tools, which prevents a 5.

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

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

There is no explicit guidance on when to use this tool over alternatives, nor any mention of context like waiting after navigation. The description only states the raw action, leaving the agent to infer that waiting is possibly needed for synchronization with other navigation or interaction tools.

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