comet-mcp

Server Quality Checklist

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

Latest release: v3.0.0
Disambiguation4/5
Most tools have distinct purposes, but 'comet_ask' and 'comet_poll' could cause confusion as both relate to agentic tasks. 'comet_ask' initiates a task, while 'comet_poll' monitors it, which might lead to misselection if an agent misunderstands their roles. Otherwise, tools like 'comet_folders', 'comet_library', and 'comet_screenshot' are clearly differentiated.
Naming Consistency5/5
All tools follow a consistent 'comet_' prefix with snake_case naming, such as 'comet_ask', 'comet_connect', and 'comet_folders'. This predictable pattern makes it easy for agents to identify and use the tools without confusion, enhancing usability across the set.
Tool Count5/5
With 8 tools, the count is well-scoped for a Comet/Perplexity integration server. Each tool serves a specific function, from connection and mode switching to research management and task control, without feeling bloated or insufficient for the domain's needs.
Completeness4/5
The tool set covers core workflows like connecting, querying, managing research, and controlling tasks, but there are minor gaps. For example, no tool explicitly handles disconnecting from Comet or clearing/resetting sessions, which agents might need for robust operation. However, the existing tools support most essential interactions effectively.
Average 3.6/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
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 states the tool searches and returns matching threads, but lacks details on permissions, rate limits, pagination, or error handling. For a search tool with zero annotation coverage, this leaves significant gaps in understanding its operational 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 concise and front-loaded, consisting of two clear sentences that directly state the action and outcome without unnecessary details. Every sentence earns its place by conveying essential information efficiently.
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 (search operation with one parameter) and no annotations or output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, usage context, or return format, leaving room for improvement in completeness.
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 'query' parameter documented as 'Search query to find past research'. The description adds minimal value beyond this, only implying the query is used to match threads. Since the schema does the heavy lifting, the 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 tool's purpose with specific verbs ('search', 'returns') and resources ('Perplexity library', 'past research threads'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'comet_ask' or 'comet_folders', which might also involve research-related operations.
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 mentions searching for 'existing research' but doesn't clarify if this is for retrieving saved results, finding related threads, or other contexts, nor does it reference sibling tools like 'comet_ask' for new research queries.
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 only states the basic action. It doesn't disclose behavioral traits such as what format the screenshot is captured in (e.g., PNG, base64), whether it requires specific permissions, if it's synchronous/asynchronous, or any error conditions (e.g., no page loaded).
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 with zero wasted words, clearly front-loading the core functionality. It's appropriately sized for a simple tool with no parameters.
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 simplicity (0 parameters, no output schema, no annotations), the description is minimal but adequate for basic understanding. However, it lacks context about output (e.g., what is returned—a file path, data URI), making it incomplete for an agent needing to handle the result effectively.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it also doesn't imply any hidden parameters or constraints, keeping it straightforward.
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 ('capture') and target ('screenshot of current page'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like comet_ask or comet_library, which might have overlapping functionality in a browser automation context.
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 prerequisites (e.g., needing a page loaded), exclusions, or comparisons to sibling tools like comet_poll or comet_stop, leaving the agent to infer context from tool names alone.
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 actions but fails to describe key traits such as authentication needs, rate limits, error handling, or what 'save current research' entails (e.g., does it overwrite existing content?). This is inadequate for a mutation tool (create/save) with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and front-loaded, using a single sentence that efficiently lists all key actions without any wasted words. Every part of the sentence earns its place by directly informing the tool's capabilities.
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 (multiple actions including mutations like create/save), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects (e.g., side effects, response format) or provide enough context for safe and effective use, falling short of what's needed for such a 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?
Schema description coverage is 100%, so the input schema already documents both parameters (action and name) thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify format for 'name' or constraints for 'save'), resulting in the baseline score of 3 where 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 with specific verbs ('list', 'create', 'save') and resource ('research folders in Perplexity'), making it immediately understandable. However, it doesn't differentiate this tool from its siblings (like comet_library or comet_connect), which might have overlapping or related functionality, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the listed actions ('list existing folders', 'create new ones', 'save current research'), but it lacks explicit guidance on when to choose this tool over alternatives (e.g., vs. comet_library for research management) or any prerequisites. This leaves the agent with some uncertainty about optimal usage scenarios.
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 that the tool stops the current agent task, implying a destructive action, but doesn't disclose key behavioral traits like whether this is reversible, what permissions are needed, or what happens after stopping (e.g., error handling, state changes). This leaves significant gaps for an agent to understand the tool's impact.
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 key action ('Stop the current agent task') and adds a conditional clause for clarity. There is no wasted wording, making it highly concise and well-structured for quick understanding.
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 complexity (a potentially destructive action with no parameters) and the lack of annotations and output schema, the description is minimally adequate. It states what the tool does but doesn't cover behavioral aspects like safety or outcomes, which are important for an agent to use it correctly. This meets the bare minimum but has clear gaps.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but that's appropriate here. A baseline of 4 is applied since there are no parameters, and the description doesn't introduce unnecessary complexity.
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 with a specific verb ('Stop') and resource ('current agent task'), and it adds a condition ('if it's going off track') that provides useful context. However, it doesn't explicitly differentiate this from sibling tools like comet_ask or comet_mode, which might also affect agent behavior.
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 when to use this tool ('if it's going off track'), which gives some guidance on context. However, it doesn't specify when NOT to use it or mention alternatives among the sibling tools, such as whether comet_mode might be a better choice for adjusting behavior instead of stopping.
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 valuable context about auto-starting the browser if needed, which goes beyond a basic 'connect' action. However, it lacks details on what 'connect' entails (e.g., establishing a session, authentication needs, error handling, or side effects), leaving gaps in understanding 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 action ('Connect to Comet browser') and includes a crucial behavioral note ('auto-starts if needed') without any wasted words. Every part of the description earns its place by adding value.
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 simplicity (0 parameters, no annotations, no output schema), the description is adequate but has clear gaps. It covers the basic purpose and a key behavioral trait, but lacks details on what 'connect' means operationally, potential errors, or how it relates to sibling tools. For a connection tool with no structured context, this leaves the agent under-informed.
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 tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds no parameter information, which is appropriate here. A baseline of 4 is applied for zero-parameter tools, as no additional semantic clarification is needed beyond what the schema provides.
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: 'Connect to Comet browser (auto-starts if needed)'. It specifies the verb ('connect') and resource ('Comet browser'), and includes the helpful behavioral detail about auto-starting. However, it doesn't explicitly differentiate this from sibling tools like comet_stop or comet_mode, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through 'auto-starts if needed', suggesting this tool should be used when a connection to the Comet browser is required. However, it provides no explicit guidance on when to use this versus alternatives like comet_stop or comet_poll, nor does it mention prerequisites or exclusions. This leaves the agent with only inferred context.
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 useful context about the tool being 'blocking' and suitable for browser interactions, but it lacks details on error handling, rate limits, authentication needs, or what constitutes a 'complete response'. This leaves gaps for a tool with potential complexity.
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 with the core purpose in the first sentence, followed by a concise elaboration on ideal use cases. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.
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 complexity (involving browser interactions and research) and lack of annotations or output schema, the description is moderately complete. It covers the purpose and usage context but omits details on return values, error conditions, and operational constraints, which are important for a blocking tool with potential timeouts.
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 (prompt, newChat, timeout). The description does not add any additional meaning or examples beyond what the schema provides, such as clarifying the format of 'prompt' or typical use cases for parameters. Baseline 3 is appropriate when the schema handles the documentation.
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 ('Send a prompt to Comet/Perplexity and wait for the complete response') and distinguishes it from siblings by specifying it's 'blocking' and ideal for 'real browser interaction' or 'deep research with agentic browsing', unlike tools like comet_screenshot or comet_folders.
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 on when to use this tool ('Ideal for tasks requiring real browser interaction... or deep research with agentic browsing'), which helps differentiate it from non-browser or non-research siblings. However, it does not explicitly state when not to use it or name specific alternatives among the 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?
No annotations are provided, so the description carries the full burden. It discloses behavioral traits such as the tool being callable repeatedly for monitoring, which implies it's non-destructive and likely read-only. However, it lacks details on rate limits, authentication needs, or specific return formats, leaving some behavioral aspects unclear. The description doesn't contradict any annotations, as none exist.
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 extremely concise and well-structured with two sentences: the first states the purpose, and the second provides usage guidelines. Every sentence earns its place by adding clear value without any waste, making it front-loaded and efficient for quick understanding.
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 complexity (simple monitoring with no parameters) and the absence of annotations and output schema, the description is moderately complete. It covers the purpose and usage but lacks details on what 'status and progress' entails (e.g., return values or error conditions). For a tool with no structured data support, it should ideally provide more behavioral context to be fully helpful.
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 input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of parameters. The description adds no parameter-specific information, which is appropriate. According to the rules, with 0 parameters, the baseline is 4, as there's nothing to compensate for, and the description doesn't detract from the schema's completeness.
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 as 'Check agent status and progress' with the specific verb 'check' and resource 'agent status and progress'. It distinguishes itself from siblings like comet_ask, comet_connect, etc., by focusing on monitoring rather than initiating actions or managing resources. However, it doesn't explicitly differentiate from all siblings (e.g., comet_mode might also relate to status), keeping it from 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance with 'Call repeatedly to monitor agentic tasks,' indicating when to use this tool (for ongoing monitoring) and implying when not to use it (for one-time checks or other operations). This distinguishes it from alternatives that might perform single actions, making it highly effective for guiding agent selection.
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 describes the tool's function and optional parameter behavior adequately, but lacks details on side effects, error handling, or performance characteristics (e.g., rate limits, permissions). It does not contradict any 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 front-loaded with the main purpose, followed by a concise list of modes and their meanings, and ends with the optional parameter behavior. Every sentence adds essential information without redundancy, making it highly efficient and well-structured.
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 (one optional parameter with enums) and no annotations or output schema, the description is mostly complete. It covers purpose, usage, and parameter semantics effectively, but could benefit from details on return values or error cases to achieve full completeness.
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 baseline is 3. The description adds value by explaining the semantics of each mode ('basic', 'deep research', 'analytics/visualization', 'educational'), which goes beyond the enum values in the schema. However, it doesn't provide additional context like default behaviors or interactions beyond what's implied.
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 ('Switch Perplexity search mode') and resource ('Perplexity search mode'), distinguishing it from sibling tools like comet_ask or comet_connect. It provides a comprehensive list of available modes with brief explanations, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('Switch Perplexity search mode') and provides clear alternatives for different scenarios (e.g., using 'search' for basic, 'research' for deep research). It also specifies the behavior when called without a mode ('to see current mode'), offering complete guidance on usage.
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:

[![comet_mcp MCP server](https://glama.ai/mcp/servers/simplicianokelly52/comet_mcp/badges/card.svg)](https://glama.ai/mcp/servers/simplicianokelly52/comet_mcp)

Score Badge

Copy to your README.md:

[![comet_mcp MCP server](https://glama.ai/mcp/servers/simplicianokelly52/comet_mcp/badges/score.svg)](https://glama.ai/mcp/servers/simplicianokelly52/comet_mcp)

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/simplicianokelly52/comet_mcp'

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