cursor-usage

Server Quality Checklist

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

Latest release: v0.1.2
Disambiguation5/5
Every tool has a clearly distinct purpose targeting specific metrics or actions, such as get_agent_edits for edit metrics, get_daily_usage for user-level data, and set_spend_limit for administrative control. There is no overlap in functionality, making it easy for an agent to select the right tool without confusion.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern with 'get_' prefix for retrieval operations and 'set_' for configuration, using snake_case throughout. This predictability enhances readability and usability for agents.
Tool Count4/5
With 17 tools, the count is slightly high but reasonable for the comprehensive analytics and management scope of Cursor usage. It covers various aspects like billing, usage, and team management without feeling overly bloated.
Completeness5/5
The tool set provides complete coverage for analytics and administrative tasks in the Cursor domain, including metrics retrieval (e.g., usage, spending, models), team management, and spend control. There are no obvious gaps, enabling agents to handle all relevant workflows effectively.
Average 3.3/5 across 17 of 17 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation (implying read-only) and describes the metrics returned, but doesn't cover important aspects like authentication requirements, rate limits, pagination, error conditions, or data freshness. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences. The first sentence clearly states the purpose and metrics, while the second adds valuable context about team effectiveness. There's no wasted language, and the information is front-loaded. It could potentially be improved with more structured guidance, but it's efficient as-is.
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 explains what metrics are returned and their purpose, but lacks details about the return format, data aggregation, or how the metrics are calculated. Without an output schema, more information about the response structure would be helpful for a complete understanding.
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 description doesn't mention any parameters, while the input schema has 100% description coverage with clear documentation of 'startDate', 'endDate', and 'users'. Since schema coverage is high (>80%), the baseline score is 3. The description adds no parameter semantics beyond what's already in the schema, but doesn't need to compensate for poor schema documentation.
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 agent edit metrics: suggested vs accepted vs rejected diffs and lines.' It specifies the verb ('Get') and resource ('agent edit metrics'), and provides meaningful context about what the metrics measure ('how effectively the team is using AI-generated code'). However, it doesn't explicitly differentiate from sibling tools like 'get_usage_events' or 'get_user_deep_dive' that might also provide related metrics.
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 the metrics show team effectiveness with AI-generated code, but doesn't specify use cases, prerequisites, or exclusions. With many sibling tools (e.g., 'get_daily_usage', 'get_user_deep_dive'), there's no indication of how this tool differs in scope or when it's the appropriate choice.
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 adoption data but doesn't describe output format, pagination, rate limits, authentication needs, or whether it's a read-only operation. For a tool with zero 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 front-loads the core purpose. It wastes no words and directly communicates what the tool does without redundancy or fluff.
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, no output schema, and 3 parameters, the description is incomplete. It doesn't explain what the return values look like (e.g., list of models with counts), error conditions, or behavioral constraints. For a tool reporting usage metrics, more context is needed for effective agent 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%, so the schema fully documents all three parameters (startDate, endDate, users). The description adds no parameter-specific information beyond what's in the schema, such as clarifying how 'users' filtering interacts with plan mode adoption. Baseline 3 is appropriate when 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 plan mode adoption: which models are being used in plan mode and how often.' It specifies the verb ('Get') and resource ('plan mode adoption'), and indicates it provides usage metrics. However, it doesn't explicitly differentiate from sibling tools like get_model_usage or get_daily_usage, which might also report model-related data.
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 get_model_usage or get_daily_usage, nor does it specify prerequisites, exclusions, or ideal contexts for usage. The agent must infer usage from the purpose 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what data is returned but doesn't cover critical aspects like whether this is a read-only operation (implied by 'Get' but not explicit), authentication requirements, rate limits, pagination behavior beyond the schema parameters, or error handling. For a tool with no annotations, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, stating the core purpose in the first sentence and listing key data points in the second. Both sentences add value by specifying the scope and output details. There's no unnecessary repetition or fluff, making it 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 moderate complexity (fetching billing data with pagination), no annotations, and no output schema, the description is partially complete. It covers what data is returned but lacks details on behavioral traits, error cases, or output structure. It's adequate for a basic read operation but doesn't fully compensate for the missing structured information, leaving room for improvement in transparency and guidelines.
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 ('page' and 'allPages') with their types and defaults. The description doesn't add any semantic details about these parameters beyond what the schema provides, such as explaining pagination context or when to use 'allPages'. Given the high schema coverage, a baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.
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 ('Get') and resource ('current billing cycle spending for all team members'), and details what information it provides (spend in dollars, included vs overage, fast premium requests, and spend limits). However, it doesn't explicitly differentiate this tool from sibling tools like 'get_billing_groups' or 'get_daily_usage', which might also relate to billing or usage data.
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 any prerequisites, exclusions, or comparisons to sibling tools such as 'get_billing_groups' or 'get_daily_usage', leaving the agent to infer usage context based solely on the tool name and description.
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 'line-level detail' which hints at granular data, but doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication requirements, data freshness, or pagination. For a usage analytics tool with zero annotation coverage, this leaves significant gaps.
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 avoids redundancy and wastes no words, though it could be slightly more structured by separating usage context from data details.
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 covers the what but lacks the how and when. Without annotations or output schema, it should ideally provide more behavioral context and usage guidance to compensate, but it meets the bare minimum for a read-oriented analytics 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 schema already documents all three parameters (startDate, endDate, users) with format details and defaults. The description adds no additional parameter semantics beyond what's in the schema, such as explaining how 'users' filtering interacts with the data or clarifying 'line-level detail' in relation to parameters. 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 tool's purpose: 'Get tab autocomplete usage: suggestions shown vs accepted vs rejected, with line-level detail.' It specifies the verb ('Get'), resource ('tab autocomplete usage'), and scope ('suggestions shown vs accepted vs rejected, with line-level detail'). However, it doesn't explicitly differentiate from sibling tools like 'get_usage_events' or 'get_daily_usage', which might also relate to usage analytics.
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, exclusions, or compare it to sibling tools like 'get_usage_events' or 'get_daily_usage' that might overlap in functionality. Usage is implied by the purpose but not explicitly 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what data is retrieved (spending, patterns, requests, preferences) but lacks details on permissions required, rate limits, response format, or whether it's a read-only operation. This is a significant gap 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 front-loads the key information ('Deep dive into a specific user's usage') and lists relevant data aspects without unnecessary elaboration. Every word contributes to understanding the tool's purpose.
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 covers what data is retrieved but omits critical behavioral details like response structure, error handling, or operational constraints, making it inadequate for a tool that likely returns complex user analytics.
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 both parameters (email and startDate). The description does not add any parameter-specific semantics beyond what the schema provides, such as format examples or constraints, resulting in a baseline score of 3.
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: to perform a 'deep dive' into a specific user's usage, listing specific aspects like spending, daily usage patterns, recent requests, and model preferences. It uses a specific verb ('deep dive') and resource ('user's usage'), but does not explicitly differentiate from sibling tools like get_daily_usage or get_spending, which might overlap in functionality.
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 does not mention any prerequisites, exclusions, or compare it to sibling tools such as get_daily_usage or get_spending, leaving the agent to infer usage context without explicit direction.
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 it mentions 'Get command usage analytics', it doesn't specify whether this is a read-only operation, if it requires authentication, what the output format looks like, or if there are rate limits. For a tool with zero annotation coverage, 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, clear sentence that efficiently conveys the tool's purpose without unnecessary words. It's front-loaded with the key information and doesn't waste space on redundant details. Every part of the sentence earns its place by specifying what is being retrieved and what kind of data it provides.
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 (analytics retrieval with date/user filtering), lack of annotations, and no output schema, the description is minimally adequate but incomplete. It explains what data is retrieved but doesn't cover behavioral aspects like authentication needs, rate limits, or output format. For a tool with 3 parameters and no structured output definition, more context would be helpful to ensure proper usage.
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%, with all three parameters (startDate, endDate, users) well-documented in the input schema. The description doesn't add any additional meaning beyond what's already in the schema, such as explaining how the analytics are calculated or what 'command usage' specifically entails. Given the 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 tool's purpose: 'Get command usage analytics: which Cursor commands are being used and how often.' It specifies the verb ('Get') and resource ('command usage analytics'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_usage_events' or 'get_daily_usage', which might also provide usage-related data.
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 sibling tools like 'get_usage_events', 'get_daily_usage', and 'get_mcp_usage' that might overlap in providing usage data, there's no indication of what makes this tool distinct or when it should be preferred over others. The description only states what it does, not when to use it.
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 the tool returns 'daily active users over time' with breakdowns, but doesn't disclose important behavioral traits: whether this is a read-only operation, what format/timezone the data uses, if there are rate limits, authentication requirements, or what happens with invalid parameters. 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?
Perfectly concise single sentence that front-loads the core purpose. Every word earns its place: 'Get daily active users over time' establishes the main function, and 'including breakdowns for CLI, cloud agent, and Bugbot usage' adds valuable specificity without redundancy.
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 read operation with 3 parameters and 100% schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks context about output format, data granularity, timezone handling, or how the breakdowns are structured. Without an output schema, the description should ideally provide more guidance about what to expect from the results.
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 3 parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions 'breakdowns for CLI, cloud agent, and Bugbot usage' which hints at output structure but doesn't clarify if these are separate parameters or result fields. 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 tool's purpose: 'Get daily active users over time' with specific breakdowns (CLI, cloud agent, Bugbot). It uses a specific verb ('Get') and resource ('daily active users'), but doesn't explicitly differentiate from siblings like 'get_daily_usage' or 'get_usage_events' that might provide similar metrics.
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 on when to use this tool versus alternatives. The description doesn't mention when this tool is appropriate compared to siblings like 'get_daily_usage', 'get_usage_events', or 'get_user_deep_dive'. There's no 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 of behavioral disclosure. It describes the data returned but doesn't cover critical aspects like whether this is a read-only operation, requires authentication, has rate limits, or involves pagination. For a data retrieval 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 purpose and lists the returned data fields without unnecessary words. Every part of the sentence adds value, 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.
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 (data retrieval with multiple fields) and lack of annotations or output schema, the description is minimally adequate. It specifies what data is returned but doesn't address behavioral traits or usage context. Without an output schema, it should ideally describe return format or structure, but it does cover the data scope, making it just viable.
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, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to compensate for any parameter gaps, and it appropriately focuses on the output data. Baseline is 4 for zero parameters.
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: retrieving billing groups with specific data fields (member lists, group-level spend, daily spend breakdown, billing cycle dates). It uses a specific verb ('Get') and identifies the resource ('billing groups'), but doesn't differentiate from sibling tools like 'get_spending' or 'get_plans' that might overlap in billing/usage domains.
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 'get_spending' or 'get_plans', nor does it specify prerequisites, contexts, or exclusions for usage. The agent must infer usage from the purpose 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?
No annotations are provided, so the description carries full burden. It describes a read operation ('Get') but doesn't disclose behavioral traits such as authentication needs, rate limits, data freshness, or whether it returns aggregated or raw data. This leaves gaps for an agent to understand 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 without unnecessary words. Every part earns its place by specifying the action, resource, and key outputs (versions and percentages), making it easy 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 adequately covers the tool's purpose but lacks details on behavioral context and return values. For a read-only analytics tool with full parameter documentation, it's minimally viable but could benefit from more operational guidance to be 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%, providing full documentation for all 3 parameters. The description adds no additional parameter semantics beyond what the schema already states, so it meets the baseline of 3 without compensating for gaps, as there are none to fill.
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 verb 'Get' and the resource 'Cursor client version distribution across the team', specifying what it retrieves (which versions are in use and percentage of users on each). It distinguishes from siblings like get_team_members or get_daily_usage by focusing on version analytics rather than user lists or time-based metrics.
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 explicit guidance on when to use this tool versus alternatives is provided. While the purpose is clear, there's no mention of prerequisites, when-not scenarios, or comparisons to sibling tools like get_team_overview or get_usage_events that might overlap in team analytics.
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 what data is returned but doesn't disclose behavioral traits like pagination behavior (implied by parameters but not explained), rate limits, authentication needs, data freshness, or whether this is a read-only operation. For a tool with 5 parameters and no annotations, 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?
Single sentence that is front-loaded with the core purpose and efficiently lists the metrics included. Every word earns its place by specifying the scope and content of the data returned, with no redundant or vague phrasing.
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 a clear purpose and data scope but lacks behavioral context (e.g., pagination, rate limits) and output details. For a read operation with 5 parameters, it's minimally adequate but leaves gaps that could hinder an agent's ability to use it correctly without trial and error.
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 5 parameters (startDate, endDate, page, pageSize, allPages). The description doesn't add any parameter-specific information beyond what's in the schema, such as date format clarifications or pagination details. Baseline 3 is appropriate when the 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 verb 'Get' and the resource 'daily usage data per user', with specific examples of the metrics included (lines added/deleted, applies, accepts, etc.). It distinguishes from siblings like get_dau (likely daily active users) or get_usage_events (likely event-level data) by focusing on aggregated daily user metrics.
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 explicit guidance on when to use this tool versus alternatives like get_dau, get_usage_events, or get_user_deep_dive. The description implies usage for daily aggregated user metrics but doesn't specify scenarios, prerequisites, or exclusions that would help an agent choose appropriately among similar 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 states the tool retrieves data ('Get top file extensions'), implying a read-only operation, but doesn't mention potential side effects, authentication needs, rate limits, or data format. 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 purpose and includes key details (metrics: AI suggestions, accepts, rejects). There's no wasted verbiage or redundancy, making it easy 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 the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is partially complete. It clarifies the purpose and metrics but lacks behavioral context (e.g., data format, limitations) and usage guidelines. Without an output schema, it doesn't explain return values, leaving gaps in understanding what the tool delivers.
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 (startDate, endDate, users) with formats and defaults. The description doesn't add any parameter-specific details beyond what's in the schema, such as explaining how 'users' filtering interacts with the metrics. Baseline 3 is appropriate when the schema handles parameter 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 ('Get top file extensions') and resource ('being edited with AI'), distinguishing it from sibling tools like get_agent_edits or get_model_usage by focusing on file extension analytics rather than agent edits or model usage. It specifies the exact metrics involved: AI suggestions, accepts, and rejects.
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 explicit guidance is provided on when to use this tool versus alternatives. While it implies usage for analyzing AI editing patterns by file type, it doesn't mention prerequisites, exclusions, or compare to siblings like get_usage_events or get_daily_usage that might offer related data. The description lacks context for tool selection.
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, the description carries full burden but only states what data is retrieved without behavioral details. It lacks information on permissions needed, rate limits, response format, pagination, or whether this is a read-only operation (implied by 'Get' but not explicit).
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 MCP tool usage') and elaborates concisely ('which MCP servers and tools are being used, and how often'). Every word contributes value with no redundancy.
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 read operation with 3 parameters and 100% schema coverage, the description is minimally adequate but lacks output details (no schema provided) and behavioral context. It covers the 'what' but not the 'how' or 'when', leaving gaps in usage guidance and transparency.
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 (startDate, endDate, users). The description adds no additional parameter semantics beyond what's in the schema, maintaining the baseline score of 3 for high coverage.
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 verb ('Get') and resource ('MCP tool usage'), specifying what data is retrieved ('which MCP servers and tools are being used, and how often'). It distinguishes from sibling tools like get_agent_edits or get_model_usage by focusing on MCP-specific usage metrics.
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 like get_daily_usage or get_usage_events. The description implies usage tracking but doesn't specify scenarios, prerequisites, or exclusions, 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.
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 adequately describes the read-only nature through 'List' and specifies the return fields, but lacks details on pagination, sorting, rate limits, authentication requirements, or error conditions. For a zero-parameter tool, this is minimally acceptable but leaves gaps in 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 action ('List all team members') and immediately specifies the key return attributes. Every word contributes to understanding the tool's function without redundancy or unnecessary elaboration.
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 output schema, no annotations), the description is adequate for basic understanding. It covers the purpose and return fields but lacks context about system behavior (e.g., data freshness, access controls) or integration with sibling tools. For a read-only list operation, this is minimally complete but could benefit from additional operational guidance.
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 appropriately focuses on output semantics by detailing the returned fields (name, email, role, removal status), which adds value beyond the empty schema. This meets the baseline for zero-parameter tools.
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 ('team members') with specific attributes returned (name, email, role, removal status). It distinguishes from siblings like 'get_team_overview' by focusing on individual members rather than team-level metrics. However, it doesn't explicitly contrast with other sibling tools beyond this implicit differentiation.
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. While the description implies it's for retrieving detailed member information, it doesn't specify prerequisites, appropriate contexts, or when to choose other tools like 'get_team_overview' for aggregated data or 'get_user_deep_dive' for individual analysis.
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 describes what data is retrieved (usage breakdown per day) but lacks details on permissions required, rate limits, pagination, error handling, or the format of the returned data. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond its basic function.
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 and adds value with a second sentence on utility, with no wasted words. It efficiently communicates essential information without redundancy, making it easy for an agent to parse and understand 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 the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the purpose and high-level use case but lacks details on behavioral traits (e.g., data format, limitations) that would help an agent invoke it correctly. Without annotations or output schema, more context on what to expect from the tool would improve 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?
Schema description coverage is 100%, with all three parameters (startDate, endDate, users) well-documented in the input schema, including formats and defaults. The description does not add any parameter-specific information beyond what the schema provides, such as explaining interactions between parameters or usage examples. Baseline score of 3 is appropriate as the schema handles 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 model usage breakdown per day') and resource ('which models are being used'), distinguishing it from siblings like 'get_daily_usage' or 'get_mcp_usage' by focusing on model-level metrics. It explicitly mentions the key data points: models used, message counts, and user counts, making the purpose highly specific and differentiated.
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 ('Essential for understanding model adoption and cost drivers'), suggesting it's for analytics and cost analysis, but does not explicitly state when to use this tool versus alternatives like 'get_daily_usage' or 'get_spending'. No exclusions or prerequisites are mentioned, leaving the agent to infer appropriate scenarios 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.
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 what metrics are returned but doesn't address important behavioral aspects like whether this is a read-only operation (implied but not stated), potential rate limits, authentication requirements, data freshness, or error conditions. 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 perfectly concise with just two sentences that each earn their place. The first sentence clearly states the purpose and enumerates the returned metrics. The second sentence provides valuable usage guidance. There's no wasted language or 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.
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 (2 parameters, no output schema, no annotations), the description does an adequate job but has clear gaps. It explains what the tool returns but doesn't address behavioral aspects or provide context about the return format. Without annotations or output schema, the agent must infer how to interpret the results. The description is complete enough for basic understanding but lacks depth for confident usage.
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 input schema already fully documents both parameters (startDate and endDate) with their types and default values. The description doesn't add any parameter-specific information beyond what's in the schema, which is acceptable given the high schema coverage. The baseline score of 3 reflects adequate but not exceptional parameter 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 tool's purpose with specific verbs ('Get a comprehensive team overview') and lists the exact metrics returned (member count, total spend, top spenders, DAU, most-used models). It distinguishes itself from sibling tools by emphasizing it's 'the best starting point for understanding your team's Cursor usage,' positioning it as a high-level summary tool rather than detailed analytics like get_daily_usage or get_spending.
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 ('the best starting point for understanding your team's Cursor usage'), which implicitly suggests it should be used first before diving into more specific sibling tools. However, it doesn't explicitly state when NOT to use it or name specific alternatives for different scenarios, which prevents a perfect score.
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 effectively communicates this is a read operation ('Get') with filtering capabilities, but doesn't mention pagination behavior (implied by page/pageSize parameters), rate limits, authentication requirements, or what happens when no filters are applied. It adds some context but leaves significant behavioral aspects unspecified.
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 perfectly concise with two sentences: the first states the core purpose and key data fields, the second specifies filtering capabilities. Every word earns its place with zero waste, and information is front-loaded appropriately.
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 (5 parameters, no output schema, no annotations), the description provides adequate but incomplete coverage. It clearly explains what data is retrieved and basic filtering, but doesn't address pagination behavior, response format, error conditions, or how unfiltered queries behave. For a tool with no output schema, more detail about return values 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 5 parameters. The description mentions filtering by 'user email and date range' which aligns with the email, startDate, and endDate parameters, but doesn't add meaningful semantic context beyond what the schema provides. The baseline score of 3 is appropriate when the 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 verb ('Get') and resource ('granular per-request usage events'), listing key data fields (model, token counts, costs, chargeable status). It distinguishes from siblings like get_daily_usage or get_model_usage by emphasizing per-request granularity rather than aggregated views.
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 ('Supports filtering by user email and date range'), indicating it's for detailed event-level analysis. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, missing full comparative guidance.
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 of behavioral disclosure. It effectively describes the tool's impact ('block the user from making requests once the limit is reached') and includes a cautionary note. However, it lacks details on permissions required, whether the change is reversible, or any rate limits, which are important for a mutation 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 two sentences, front-loaded with the core purpose and followed by a cautionary note. Every sentence earns its place by adding critical information, with no wasted words or redundancy.
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 this is a mutation tool with no annotations and no output schema, the description is moderately complete. It covers the purpose, impact, and caution, but lacks details on permissions, reversibility, or response format. For a tool that modifies user access, more behavioral context would be beneficial to ensure safe usage.
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 both parameters ('email' and 'limitDollars') adequately. The description adds minimal value beyond the schema by mentioning 'in dollars' and implying the limit is for a team member, but it does not provide additional syntax, format details, or constraints beyond what the schema specifies.
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 ('Set a hard spending limit'), the resource ('for a specific team member'), and the unit ('in dollars'). It distinguishes this tool from its sibling tools, which are primarily read-only 'get' operations, by being the only tool that modifies spending limits.
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 block the user from making requests once the limit is reached') and includes a cautionary note ('Use with caution'). However, it does not explicitly mention when not to use it or name specific alternatives among the sibling tools, such as using 'get_spending' to check current spending before setting a limit.
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:

[![cursor-usage MCP server](https://glama.ai/mcp/servers/ofershap/cursor-usage/badges/card.svg)](https://glama.ai/mcp/servers/ofershap/cursor-usage)

Score Badge

Copy to your README.md:

[![cursor-usage MCP server](https://glama.ai/mcp/servers/ofershap/cursor-usage/badges/score.svg)](https://glama.ai/mcp/servers/ofershap/cursor-usage)

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/ofershap/cursor-usage'

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