cursor-cortex

by flores-ac

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

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

Latest release: v1.2.0
Disambiguation4/5
Most tools have clearly distinct purposes, but a few like search_branch_notes and comprehensive_knowledge_search overlap in search functionality, and archive_branch_note/clear_branch_note both handle archiving. However, descriptions clarify boundaries well enough to avoid serious misselection.
Naming Consistency3/5
The server consistently uses snake_case, but conventions vary: many tools follow verb_noun (read_branch_notes, generate_commit_message) while others are noun phrases (enhanced_branch_survey, timeline_reconstruction, graphql_knowledge_query). This mixed pattern makes tool names slightly less predictable.
Tool Count2/5
With 38 tools, this server is over-scoped. Many tools are process sub-steps (e.g., request_thinking_guidance, add_perspective, complete_synthesis_step) that could be consolidated or parameterized. The high count increases cognitive load and feels excessive for a single MCP server.
Completeness4/5
The tool set covers the full knowledge lifecycle: creating, reading, updating, searching, archiving, and sharing knowledge, plus specialized analysis and decision workflows. Minor gaps exist (e.g., no delete for tacit knowledge, no update for context files after creation), but core workflows have no dead ends.
Average 3.5/5 across 38 of 38 tools scored. Lowest: 2.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 10 commits in the last 12 weeks
- Last stable release on October 19, 2025
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
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, the description carries the full burden of behavioral disclosure. It fails to state whether the tool performs a read-only operation, what the output looks like, or any side effects. The phrase 'provides guidance' suggests a non-mutating action, but that is implicit and not explicitly confirmed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded, but it may be too terse to be useful. It states the purpose in one sentence without unnecessary fluff, but the sentence is vague and doesn't earn its place by providing actionable details. It's concise but lacks substance.
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 there is no output schema and no annotations, the description needs to explain what the tool returns and how it fits into the larger workflow. The description is minimal, leaving ambiguity about the nature of the 'guidance' and how it relates to sibling tools like timeline_reconstruction or update_context_file. This is a clear gap for a 4-parameter 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 coverage is 100%, so all parameters have descriptions. The description adds minimal value beyond the schema, only echoing 'timeline data' and 'sync type.' It doesn't clarify the relationship between parameters or the expected format of timelineData, but the schema already handles basic semantics, so a baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear resource ('project contexts') and a general action ('syncing') but uses the weak verb 'provides contextual guidance,' which is vague and doesn't distinguish this tool from siblings like 'request_thinking_guidance' or 'timeline_reconstruction.' It conveys the core idea but lacks specificity.
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 implies use cases via 'based on timeline data and sync type' but gives no explicit when-to-use guidance, prerequisites, or comparison to alternative tools. There is no mention of when this tool is preferred over related siblings, leaving the agent to guess.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It fails to mention what the tool does to the project, what inputs are processed, what the output looks like, or any side effects. The phrase 'Knowledge Archaeology techniques' is vague and conveys no concrete behavioral information.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise, but it is dense with jargon and metaphor ('Weaves scattered technical details', 'Knowledge Archaeology techniques') making it less immediately parseable. It is not overly long, but the structure could be improved by front-loading the concrete function before the metaphorical label.
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?
The tool has 5 parameters, no output schema, and no annotations, so the description must explain the tool's role and behavior. It does not mention what kind of narrative is produced, how the parameters influence the output, or how it fits into the broader pipeline beyond 'Phase 2.1'. This is inadequate given the tool's complexity.
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 already covers all 5 parameters with descriptions, so the baseline is 3. The description itself adds nothing specific about parameter usage, such as how narrativeType affects the result or how includeContext impacts the narrative. It does not contradict the schema but adds no additional semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it 'Weaves scattered technical details into coherent production stories', which clearly indicates the tool constructs narratives. It distinguishes itself as a 'Narrative Construction Engine' from sibling tools like timeline_reconstruction, though it doesn't explicitly compare. However, the use of jargon like 'Knowledge Archaeology techniques' slightly obscures the core function.
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 such as timeline_reconstruction or generate_commit_message. The description does not mention prerequisites, suitable scenarios, or exclusions, leaving the agent to infer usage solely from the tool name.
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 only says 'update' without revealing whether the update overwrites or appends, how scopes are applied, whether pipelineName is required for pipeline scope, or any side effects. This is a significant transparency gap for a mutation tool.
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 concise sentence with no filler, making it easy to parse. It is appropriately short, though it sacrifices informational substance for brevity.
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?
The tool is complex with 12 parameters, an enum scope, and no output schema or annotations. The description does not explain how scope influences required fields, what 'context file' refers to, or how it relates to sibling context tools, leaving the agent without critical usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers all 12 parameters with descriptions, achieving 100% coverage, so the schema already provides parameter semantics. The description adds no parameter-level information and thus provides no additional value beyond the schema baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('update') and resource ('context file'), but 'context file' is vague and not clearly tied to the project/branch/pipeline scopes present in the schema. It also does not differentiate this tool from sibling tools like update_branch_note or read_project_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?
There is no guidance on when to use this tool versus alternatives, no mention of scope selection, prerequisites, or exclusions. The usage is only implied by the tool name and generic description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It merely restates the action of archiving without explaining what archiving does to the notes (e.g., whether it moves them, marks them, or is reversible). This is essentially a tautology that adds no behavioral context.
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 concise sentence with no filler words, front-loading the verb and object. It is efficiently structured, but the brevity borders on under-specification given the need for more behavioral context; still, it earns its place by stating the core 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?
The tool has no annotations, no output schema, and relatively simple parameters, yet the description does not cover the context needed for correct selection or invocation. It fails to explain what archiving means, when to use it versus siblings, or the consequences of the action. This is a significant completeness gap.
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 coverage is 100%, with all three parameters described adequately (branchName, archiveDate, projectName). The description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate. The phrase 'for a project' weakly mirrors projectName but adds no new insight.
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 uses a specific verb 'archive' with the resource 'branch notes' and adds scope 'for a project'. It clearly states the tool's function, but it does not explicitly differentiate from sibling tools like clear_branch_note or update_branch_note, though the action is distinct.
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 that archiving is a non-destructive alternative to clearing, or when it is preferable to update or read branch notes. No exclusions or alternative tool references are given.
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 only says 'Add', implying mutation, but doesn't state whether the separator is appended, inserted, or overwritten, or what happens if the branch note is missing. No side effects or return behavior are mentioned.
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?
A single sentence, front-loaded with the verb and object, with no redundant words. It is highly concise and structured effectively for quick parsing.
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?
With 4 required parameters and no output schema or annotations, the description is insufficiently complete. It lacks context about when this operation is necessary, how it interacts with existing branch note content, and what the expected result is. The tool's specific role within the branch note workflow is not explained.
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 coverage is 100% with each parameter described, so the description adds little beyond grouping them as 'commit metadata'. It doesn't explain relationships between parameters (e.g., why projectName is needed alongside commitHash) or any special formatting. Baseline 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 action ('Add') and the resource ('commit separator to the branch note'), which distinguishes it from sibling tools like clear_branch_note or update_branch_note. However, it doesn't elaborate on what a 'commit separator' is, leaving some ambiguity for an agent unfamiliar with the domain.
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?
There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., whether a branch note must already exist), nor does it reference sibling tools like update_branch_note or clear_branch_note for comparison.
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 the full burden of disclosing side effects. It mentions 'analyzes' (read-like) and 'create' (potential write), but doesn't state whether files are created on disk, what permissions are needed, or what the return value looks like. The lack of output schema makes this gap more significant.
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 concise sentence with no filler or repetition. It efficiently conveys the main purpose and adds a phase reference. It earns a 4 for being appropriately sized, though it could be slightly more detailed without becoming verbose.
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?
Despite having 7 parameters and no output schema, the description gives minimal context. It doesn't explain what the generated checklist contains, whether any files are modified, or how results are returned. For this complexity level, the description is incomplete and leaves the agent under-informed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all 7 parameters are already documented. The description adds no extra semantic meaning beyond what the schema provides, which aligns with the 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 function: analyzing folder structure to identify documentation gaps and create checklists. It names a specific verb ('Analyzes') and resource ('folder structure'), making the core purpose obvious. However, it doesn't explicitly distinguish this from related sibling tools like 'create_completion_checklist' or 'construct_project_narrative', so it misses the top score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only usage hint is 'Phase 2.3', which implies it's part of a larger workflow but offers no explicit when-to-use or when-not-to-use guidance. It doesn't mention alternatives or prerequisites, leaving the agent to guess when this tool is appropriate compared to its many siblings.
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 only says 'create' with no mention of side effects, persistence, permissions, or return values, leaving significant ambiguity.
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 concise sentence, front-loaded with the action and resource. It is efficient but omits potentially valuable context, so it doesn't earn a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a create tool with 11 parameters, no annotations, and no output schema, the description is underspecified. It doesn't explain the template's structure, what happens on creation, or how to handle the result, leaving significant gaps.
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 parameters are well-documented in the schema itself. The description adds only a vague template reference, which doesn't materially enhance understanding beyond the schema.
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 it creates a tacit knowledge document, with a specific template reference. The resource is distinct from sibling tools like read_tacit_knowledge, though it doesn't explicitly differentiate from other create tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The sibling list implies a read counterpart, but the description doesn't mention 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?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. While 'Read' implies a non-destructive operation, it does not explicitly confirm that there are no side effects, nor does it describe the return format or behavior when checklistName is 'list.' The special list behavior is only in the schema, not the tool description, so an agent relying on the description may not anticipate this capability.
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, concise sentence with no extraneous words. Every word earns its place, and it clearly communicates the core function without unnecessary detail. This is appropriately minimal for a simple read operation.
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?
Despite being a simple tool, the description is incomplete for an agent to fully understand the tool's behavior. There is no output schema, no annotations, and no explanation of what 'read' returns, how to see all checklists, or any relevant caveats. The schema helps with parameters but does not fill the gap for expected output or edge cases like the 'list' option.
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%, as both projectName and checklistName have descriptions. The tool description adds no additional parameter semantics beyond the schema, so it does not improve on what structured fields already provide. A baseline of 3 is appropriate because the schema adequately documents the 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 uses the specific verb 'Read' and identifies the resource as a 'completion checklist for the project,' which clearly states the primary action. It distinguishes from siblings like create_completion_checklist and update_checklist because those imply modification, while this is purely a read operation. However, it does not mention the ability to list all checklists via the checklistName parameter, which is a notable feature but not essential for basic purpose clarity.
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 lacks any mention of preconditions, typical use cases, exclusions, or related tools. Sibling tools like read_tacit_knowledge and sign_off_checklist exist, but the description does not explain when a completion checklist should be read versus other context-reading operations.
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 must carry the full burden of behavioral disclosure. It simply says 'sign off' without revealing what that entails—whether it records a signature, makes the item immutable, requires permissions, or has side effects. This is especially important for a state-changing tool, and the description is too vague.
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 with no fluff or repetition. It is appropriately sized for a simple action, though it could benefit from additional context without becoming wordy. It is not under-specified to the point of being a tautology like 'Process.'
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, the absence of an output schema, and the fact that this is a sign-off (likely a state-changing and possibly consequential action), the one-line description is insufficient. It does not explain what happens on sign-off, whether it is reversible, what the user receives as confirmation, or how it relates to sibling tools like update_checklist. The description leaves too much to be inferred.
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 provides descriptions for all four parameters, achieving 100% coverage, so the baseline is 3. The description does not add any extra meaning to the parameters beyond what the schema already states, but it also does not need to because the schema is thorough.
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 'Sign off on a completed checklist item' clearly identifies the action (sign off) and the resource (checklist item), and it is distinct from sibling tools like read_checklist or update_checklist because it refers to a specific sign-off action. However, it does not explicitly differentiate itself from alternatives or mention the workflow positioning beyond the basic action.
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?
There is no explicit guidance on when to use this tool versus alternatives. The only implied condition is 'completed checklist item,' but there is no mention of prerequisites (e.g., checklist must exist), whether to use it before or after other tools, or when not to use it. This lacks the context needed for an agent to know when to invoke 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 the full burden of behavioral disclosure. It implies mutation but doesn't state whether the operation appends to the existing note or replaces it, whether permissions are required, or whether changes are reversible. 'Update ... with a new change entry' hints at appending but leaves critical ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant or filler wording. It efficiently communicates the core action and object without wasted space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, a one-sentence description is insufficient. It doesn't explain the 'running note' concept, append vs. overwrite behavior, return value, error conditions, or its relationship to sibling tools like archive_branch_note and read_branch_notes.
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 baseline is 3. The description's 'new change entry' and 'current branch' loosely map to message and branchName, but it doesn't add parameter-level detail beyond what the schema already 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 action ('Update') and the object ('the running note for the current branch') and indicates the payload ('a new change entry'). This distinguishes it from sibling tools like read_branch_notes, clear_branch_note, and archive_branch_note. However, 'current branch' is slightly ambiguous given the required branchName parameter, and 'running note' is a domain-specific term not explained.
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, nor are prerequisites or exclusions mentioned. The verb 'update' and sibling names imply usage, but the description doesn't state when to prefer this over related tools like update_context_file or how it relates to archive/clear operations.
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 the full burden of behavioral disclosure, but it only restates the core function. It does not mention side effects, return format, behavior on missing files, or how currentProject affects the read, providing little beyond the tool's name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded phrase with no wasted words. It fully captures the essence of the tool without excess, making it appropriately concise.
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?
Despite the tool's simplicity, the lack of an output schema means the agent cannot know what this tool returns (e.g., file contents, metadata) or how currentProject influences behavior. The description does not compensate for this gap, leaving it incomplete for effective invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% description coverage for parameters, with clear descriptions for projectName, pipelineName, and currentProject. The tool description adds no additional parameter semantics, so the baseline score of 3 is appropriate given the schema's completeness.
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 'Read pipeline-specific context file' clearly states the verb (read), the resource (context file), and the scope (pipeline-specific), distinguishing it from sibling tools like read_project_context and read_branch_context. It is specific and unambiguous.
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 name implies pipeline context, there is no explicit mention of when to choose it over read_project_context or read_branch_context, and no exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavioral traits. It only says 'update,' implying a mutation, but does not explain whether existing items are overwritten, how autoUpdate behaves, what the return value is, or any permissions needed. This is insufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no redundant wording. It front-loads the core action and resource, making it easy to quickly understand 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?
This tool has six parameters and two distinct update modes (manual via itemPath/status and auto via autoUpdate), yet the description is extremely brief. It does not explain how these modes interact, prerequisites, or outcomes. Given no output schema or annotations, more detail is necessary for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all six parameters with descriptions, so the baseline is 3. The description's mention of 'branch context and progress' loosely hints at the autoUpdate and branchName parameters but adds little detail beyond what the schema already 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 identifies the action ('update') and the resource ('checklist items'), and adds contextual basis ('based on branch context and progress') that helps distinguish it from siblings like read_checklist or sign_off_checklist. However, it does not specify whether it updates a single item or the entire checklist, which leaves some ambiguity.
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 phrase 'based on branch context and progress' implies a use case for updating items when branch information is relevant, but it does not explicitly state when to use this tool over alternatives like update_branch_note or read_checklist. No exclusions or alternative references are provided.
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 bears full responsibility for disclosing behavior. It mentions 'semantic-first' and 'AI-powered semantic understanding by default' but does not clarify that searches are read-only, how results are ordered, whether pagination exists, or any side effects. This is insufficient for a tool of this complexity.
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 two sentences long and front-loads key terms like 'Global semantic-first search'. It is concise and easy to parse, though there is minor redundancy between 'ALL' and 'entire knowledge base'.
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?
With 7 parameters and no output schema, the description must provide more context. It does not describe the return format, result ordering, or how to refine searches. It also fails to address potential use cases or limitations, leaving significant gaps for an agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter having a description. The tool description adds context by linking 'semantic-first' and 'by default' to the semanticSearch flag, but it does not elaborate on individual parameters beyond what the schema already provides. Baseline of 3 is appropriate.
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 identifies the tool's action ('search') and its comprehensive scope ('ALL Cursor-Cortex knowledge including branch notes, tacit knowledge, archives, and context files'). It distinguishes itself from sibling tools like search_branch_notes by emphasizing its global, semantic-first nature.
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 this tool is for global, cross-knowledge search but does not explicitly state when to use it versus alternatives such as search_branch_notes or graphql_knowledge_query. It lacks explicit exclusions or comparisons, leaving usage decisions to inference.
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 the full burden of disclosing behavior. It mentions 'Uses AI-powered semantic understanding by default' but does not address whether the operation is read-only, whether any state is modified, permission requirements, or output format. For a tool with no annotations, this is insufficient.
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 two sentences, front-loaded with the tool's purpose and key capabilities. It is efficient and avoids unnecessary fluff, though the phrase 'for Knowledge Archaeology' adds domain context without being directly functional.
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?
The tool has 7 optional parameters, no output schema, and no annotations, so the description must explain return values and behavioral context. It provides a high-level overview but omits what the output looks like, how parameters interact, and any edge cases or prerequisites. This is incomplete for a tool of this complexity.
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 coverage is 100%, so parameters are fully documented in the schema. The description adds context like 'semantic search' and 'completeness scoring' which map to parameters like semanticAnalysis and minCompletenessScore, but it does not provide additional parameter-level detail beyond the schema. Baseline of 3 is appropriate.
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 identifies the tool as a 'branch survey system' with specific functions: semantic search across all branches, completeness scoring, relationship mapping, and production readiness assessment. This distinguishes it from sibling tools like comprehensive_knowledge_search or search_branch_notes, which focus on search rather than a holistic survey with scoring.
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 use when a comprehensive, semantic analysis of branches is needed, but no explicit guidance is given on when to prefer this over alternatives like comprehensive_knowledge_search or timeline_reconstruction. It lacks clear 'when to use / when not to use' instructions.
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, the description carries the full burden. It adds a useful behavioral detail (defaults to uncommitted work) but does not disclose safety, permissions, or return characteristics. For a read operation this is somewhat acceptable, but additional context would improve transparency.
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, compact sentence that front-loads the main action and includes key behavioral details. Every word has purpose, with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters and no output schema, the description is sparse but sufficient for a straightforward read operation. It covers the main feature but does not explain output format, edge cases, or interaction between filters. Could be more complete given the tool's complexity.
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 baseline is 3. The description summarizes the date range filter and uncommitted default, but this adds little beyond the existing parameter descriptions. No extra semantic value is provided.
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 'Read branch notes' and specifies default behavior (uncommitted work) plus filtering options. It differentiates from siblings like list_all_branch_notes by focusing on the read operation with filters, though it doesn't explicitly mention branch/project scoping beyond the required parameters.
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 search_branch_notes or list_all_branch_notes. The description implies usage for reading a specific branch's notes but does not give explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a write operation ('Create') but does not disclose side effects, permissions, reversibility, or what happens to existing checklists. The mention of a template adds minimal context, but significant gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the action and resource. It is appropriately sized with no fluff or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 8 parameters, no annotations, and no output schema, the description is too sparse to be complete. It lacks context about the template, what a completed checklist entails, return values, or any prerequisites. Sibling differentiation is absent, and the description does not compensate for the lack of structured metadata.
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%, and each of the 8 parameters has a clear description. The tool description adds no parameter-specific meaning, but the schema already fully documents them, so baseline 3 is appropriate.
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 uses a specific verb ('Create') and resource ('project completion checklist') plus a method ('using the Cursor-Cortex template'). It clearly distinguishes from sibling tools like read_checklist and update_checklist by indicating this is the creation operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating a checklist but does not explicitly state when to use it vs. alternatives like read_checklist or update_checklist. No exclusions or alternative tools are mentioned, so usage context is only implied rather than explicit.
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 must carry the full behavioral burden. It only discloses that no commit is made, leaving unaddressed how the branch note is retrieved, potential side effects, or behavior when no branch note exists. This is a significant gap for a tool with no annotation safety 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, tight sentence that front-loads the action ('Generate a commit message') and the key constraint ('without making the commit'). No wasted words or filler content.
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?
With no output schema and no annotations, the description must explain the tool's behavior and return value, but it does not. It also fails to define what a 'branch note' is or how it is accessed, leaving the agent with significant unknowns about execution and expected 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%, with all three parameters described in the input schema. The tool description does not add any extra parameter semantics—its mention of 'branch note' is too vague to clarify how parameters like branchName interact. Baseline 3 is appropriate due to complete schema 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 that the tool generates a commit message (verb+resource), specifies the source as 'based on the branch note', and explicitly notes it does not commit. This distinguishes it from commit-execution tools and sibling tools like generate_jira_comment.
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 phrase 'without making the commit' implies that this tool is for generating a message only, but the description does not explicitly state when to use it versus alternatives, nor does it name any sibling tools as alternatives. The usage context is implied rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only states 'List' which implies read-only, but does not explicitly confirm safety, mention permissions, return format, or any side effects. It lacks details about what constitutes a context file or how results are ordered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the action and resource. Every word contributes meaning, with no redundant or filler content.
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?
The tool has no output schema and no annotations, so the description should cover return values and behavior. It does not explain what the returned list contains, how listAll interacts with the required projectName parameter, or any constraints. This leaves significant gaps for an agent to correctly invoke and interpret 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 all parameters already have descriptions. The description adds minimal value beyond the schema by clearly stating the two modes (project vs all projects), but it does not significantly clarify the relationship between listAll and required projectName, nor the role of currentProject.
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 'List' and the resource 'context files', with scope 'for a project or across all projects'. This effectively distinguishes it from sibling tools like list_all_branch_notes, which targets branch notes, and read_* tools, which read specific context.
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 by specifying the two modes (single project vs all projects) but does not provide explicit when-to-use guidance or name alternatives. It gives clear context on what it does, but no exclusions or comparison to sibling tools like read_project_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, the description carries the full burden. It correctly indicates a read operation, implying non-destructive behavior, and includes a scope restriction. However, it does not disclose return format, error handling, or access requirements, so transparency is minimal but not misleading.
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 sentence, front-loaded with the core action, and contains no superfluous words. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool, the description states the core function and a scope, but it fails to explain what a 'context file' contains, how it relates to the branchName parameter, or when to choose it over similar reading tools. The ambiguity of 'current branch context only' leaves significant gaps for an agent to understand the full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides descriptions for all three parameters (100% coverage), and the tool description does not add any additional meaning about the parameters. The baseline score of 3 applies because the schema covers the semantics completely.
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 'Read' and the specific resource 'branch-specific context file', with a scope qualifier '(current branch context only)' that distinguishes it from reading project or pipeline contexts. This clearly differentiates from sibling tools like read_project_context and read_pipeline_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?
No explicit guidance on when to use this tool versus alternatives is provided. The phrase 'current branch context only' hints at a scope restriction but does not name alternatives or give conditions for selection. It leaves the AI agent to infer the intended use case.
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?
The verb 'Read' implies a non-destructive operation, and the description outlines three access behaviors. However, with no annotations provided, the description carries the full burden and does not disclose output format, result size, or whether semantic search triggers side effects like embedding generation.
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, focused sentence that front-loads the core action and then efficiently lists the supported access modes. Every phrase contributes to understanding the tool's purpose; there is no padding.
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 7-parameter tool with no output schema, the description omits important context such as tag filtering (searchTags) and cross-project search (crossProject). It also does not explain what is returned (e.g., full document content vs. metadata), leaving gaps for an agent to resolve.
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?
Schema coverage is 100%, but the description adds meaningful structure by grouping parameters into three usage modes: exact filename (documentName), text search (searchTerm), and semantic search (semanticSearch + similarityThreshold). This provides context beyond individual parameter descriptions.
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 reads tacit knowledge documents and identifies three distinct access modes (filename, text, semantic). This is a specific verb+resource combination, but it does not explicitly contrast with sibling tools like search_branch_notes or comprehensive_knowledge_search, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. The description is purely capability-focused and does not mention exclusions, prerequisites, or scenarios where a sibling tool would be more appropriate.
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, the description carries the full burden. It discloses that clearing can optionally be preceded by archiving, which is useful context for destructive behavior. However, it does not state whether the operation is permanent, whether the header is preserved (despite the keepHeader parameter), or any side effects on related files.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It conveys the action and the key optional behavior 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?
The tool has 4 parameters, no output schema, and no annotations. The description provides the core action but omits important context for a potentially destructive operation: reversibility, exact effects on notes, and when to use it relative to archiving. It is adequate but leaves gaps.
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 four parameters. The description adds minimal value beyond aligning with 'createArchive' and 'projectName', but does not enhance understanding of branchName or keepHeader beyond their schema definitions.
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 uses a specific verb ('clear') and resource ('branch notes') with a scoping qualifier ('for a project'), making the primary purpose clear. However, it does not explicitly distinguish itself from the sibling tool 'archive_branch_note', though the optional archive-first behavior hints at the relationship.
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 action itself (clear branch notes) but provides no explicit when-to-use guidance or alternatives. It does not mention that archive_branch_note might be used if archival without clearing is desired.
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 transparency burden. It does disclose the main behavior: showing which perspectives are complete and missing. However, it does not mention whether the operation is read-only, what return format to expect, or any side effects. The phrase 'prevents rushed decisions' adds rationale but not deeper behavioral detail.
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 long and front-loaded with the core purpose. Every sentence adds value: the first states what it does, the second explains the benefit and the specific data shown. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple status-check tool with two straightforward parameters, the description provides the essential purpose and key information about what is shown. However, with no output schema and no annotation, it lacks details on return format or behavior when analysis is incomplete. It is adequate but leaves some gaps for the agent to infer.
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 already provides descriptions for both parameters (analysisId and projectName) at 100% coverage. The description adds no additional parameter semantics beyond what the schema documents, so the baseline of 3 is appropriate.
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 identifies the tool's function with a specific verb ('Check') and resource ('completion status of a critical thinking analysis'), and specifies the unique scope of 'Six Thinking Hats perspectives'. This distinguishes it from sibling tools like request_critical_thinking_space or add_perspective, which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used before making decisions by stating it 'prevents rushed decisions', but it does not explicitly state when to use it versus alternative tools, nor does it mention any prerequisites or exclusions. There is no reference to sibling tools or conditions for alternative actions.
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, the description carries the burden of behavioral disclosure. It discloses the conversion and preservation behavior, but it does not mention the default dryRun=true behavior, backup creation, or potential overwriting of existing context files. These are partially covered by the schema's parameter descriptions but not surfaced in the main description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no wasted words. The description is front-loaded with the action and resource, and the second sentence clarifies the specific outcomes.
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?
The tool has a moderate complexity with four parameters, an enum, and no output schema. The description gives the core purpose and conversions, but lacks details on return values, side effects, verification steps, or when to use this migration tool versus other context-related tools. It is minimally sufficient but not richly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds context by naming project_context.md and branch-specific contexts, which helps clarify the migrationStrategy parameter, but does not add substantial meaning beyond the parameter descriptions already present.
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 uses a specific verb ('Migrate') and resource ('existing context files') and clearly states the destination system and conversion behavior ('Converts main/master contexts to project_context.md and preserves branch-specific contexts'). This clearly distinguishes it from sibling tools like update_context_file or read_project_context.
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 its use case: when you want to migrate existing context files to the Smart Hybrid Context System. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites.
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, the description carries the full burden. It adds behavioral context ('semantic search', 'across projects') but does not disclose the non-destructive nature, result format, or any edge-case behavior. It is adequate for a read-oriented search tool, but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It efficiently states the action and purpose, earning full marks for conciseness and structure.
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?
The description clarifies the tool's purpose and content domain, but with no output schema and no annotations, it does not explain what results look like or mention filtering/sorting options (though schema handles those). It is reasonably complete for a search tool but leaves some context gaps.
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 baseline is 3. The description adds no parameter-specific detail beyond what the schema already provides, merely echoing the semantic search and project scope concepts. Thus it does not elevate beyond baseline.
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 a specific verb ('Search') and resource ('branch notes across projects'), and the semantic search qualifier distinguishes it from simpler listing tools like list_all_branch_notes. It also provides a sense of content ('development insights, problem-solving journeys, decision contexts'), making the purpose unmistakable.
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 the tool (when seeking insights from branch notes) but does not explicitly state when to use it vs alternatives like comprehensive_knowledge_search, nor does it mention any exclusions. The usage context is clear enough, but explicit alternatives are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions regeneration (implying overwrite) and scope (all files), but doesn't detail side effects, cost, authentication requirements, or whether the operation is idempotent. This is a moderate gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and every word adds value. No redundancy or filler.
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?
For a tool with no output schema and 3 optional parameters, the description is largely complete: it states scope, action, and outcome. However, it could add context about when to run it (e.g., after knowledge updates) and any caveats, but overall it's sufficient for a straightforward batch operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all three parameters (verbose, projectName, forceRegenerate) with 100% coverage. The description adds no parameter-level detail, so it neither helps nor hinders beyond the schema, earning the baseline 3.
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 verb (generate/regenerate), resource (vector embeddings), and scope (all Cursor-Cortex knowledge files). It also explains the outcome (enables semantic search), distinguishing it from sibling search tools like comprehensive_knowledge_search.
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 (generate embeddings to enable semantic search) but provides no explicit guidance on when to run it, such as after updating knowledge files, or when not to use it. It also doesn't mention alternatives, though the tool's purpose is fairly distinct from 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 burden. It states that knowledge is packaged into a ZIP archive, implying a read/export operation, but it does not disclose side effects (e.g., whether existing files are overwritten), prerequisites, or scope (e.g., all projects by default). The description adds some context but not deep behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. It immediately states the action and purpose, and every phrase contributes meaning.
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?
With 5 parameters, no annotations, and no output schema, the description is minimal. However, the schema fully documents all parameters, and the tool's purpose is simple (zip creation). It would benefit from noting default behavior (e.g., includes all projects/branches) and whether the ZIP replaces existing files, but it is not severely incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides. The schema itself includes informative descriptions for includeTypes and projectNames, so no significant gap exists.
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 uses a specific verb 'Package' and identifies the resource 'Cursor-Cortex knowledge' with a clear output: 'a portable ZIP archive for sharing between users and environments'. This clearly distinguishes it from sibling tools that read, write, or search individual knowledge items.
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 conveys the context for use ('for sharing between users and environments') without explicitly listing when not to use it or naming alternatives. It is clear enough that an agent would know to use this tool for packaging knowledge, while siblings cover other operations. No exclusions are mentioned, but the intent is explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It adds one important operational detail ('Requires the GraphQL server to be running') but does not mention that queries are read-only/non-destructive, potential rate limits, or what happens if the server is unavailable. This is a moderate level of transparency for a query tool.
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 with no filler. The first sentence efficiently lists the tool's core capabilities, and the second covers the operational prerequisite. Every word contributes meaning.
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?
The tool is complex due to the open-ended nature of GraphQL, and there is no output schema. The description gives a high-level overview and the schema covers parameters, but it does not clarify what the response format will be, error handling, or examples of typical queries beyond what the schema shows. This leaves some ambiguity for an agent deciding whether to invoke the 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%, with each parameter already well-documented (query includes examples, endpoint has a default, variables are described). The description adds no parameter-specific meaning beyond what the schema provides, so 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.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies a verb ('Query'), a resource ('GraphQL Knowledge Hub API'), and distinct use cases ('structured knowledge discovery, project graph traversal, pipeline exploration, cross-project relationship analysis'). It uniquely distinguishes this tool from all sibling tools, which are focused on notes/context rather than direct GraphQL access.
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 the tool (for GraphQL-based knowledge discovery and graph traversal) and mentions a prerequisite (server must be running). However, it does not explicitly exclude alternatives or name competing tools. This is still sufficient because the sibling tools serve different purposes.
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 several behavioral traits: it loads all perspectives, starts a stepped synthesis process, and sets up a synthesis semaphore. However, it does not explain side effects like reversibility, error behavior if the precondition is not met, or how to release the semaphore. This is meaningful but incomplete.
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. The three sentences each serve a purpose: the core action, the requirement, and the mechanism. There is no redundant or filler content, and it earns a high score for efficiency.
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?
The tool is part of a multi-step synthesis workflow, but the description does not explain what happens after invocation, what the return value is, or how to proceed with subsequent steps. It mentions starting a stepped process but not the steps themselves. There is no output schema to fill the gap, so the description is adequate but not 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?
The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds no extra meaning about the parameters—it does not mention analysisId or projectName at all. The schema already explains that analysisId is the target and projectName is the project.
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 action: 'Load all Six Thinking Hats perspectives into synthesis workspace and start stepped synthesis process.' It identifies a specific verb (load/start), resource (synthesis workspace/process), and differentiates from sibling tools like request_critical_thinking_space by focusing on synthesis.
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 an explicit precondition: 'REQUIRES all 6 perspectives to be completed first.' This tells the agent when to use the tool and implies that other tools should be used beforehand if perspectives are incomplete. It does not explicitly name alternatives or exclusions, but the requirement gives clear 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, the description carries the full burden. It discloses a key behavioral trait (fails if guidance not requested) and states it updates the process, but it does not explain side effects, reversibility, or return behavior. This is useful but limited.
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 primary action, and the critical requirement is prominently emphasized in uppercase. Every word adds value, with no redundancy.
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 a 4-parameter schema with all parameters described and no output schema, the description provides sufficient context for execution. It includes the essential prerequisite and the action's purpose, making it complete for an agent to use correctly. A full 5 is not given because it does not explain what happens to the overall synthesis process in more detail.
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?
All four parameters have descriptions in the schema (100% coverage), so the baseline is 3. The description does not add additional semantic detail beyond what the schema provides, such as formatting or relationship between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Complete' with a clear resource 'synthesis step' and specifies the effect 'update the synthesis process.' It distinguishes itself from related tools like request_synthesis_step_guidance by focusing on the completion action.
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 explicitly states a precondition: 'REQUIRES calling request_synthesis_step_guidance first for this step' and a failure mode if not followed. This provides clear when-to-use guidance, though it does not mention alternative tools or situations where this tool should not be used beyond the prerequisite.
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, the description carries the full burden. It conveys that this is a read operation and branch-agnostic, but it does not disclose the cross-project warning behavior hinted by the currentProject parameter, nor does it mention return format or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the verb and resource and contains no filler.
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?
For a simple read tool with full schema support and no output schema, the description is sufficient. It distinguishes from siblings but does not explicitly state the return content.
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 coverage is 100% and the description adds no additional parameter meaning, so the baseline of 3 applies.
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 reads a project context file, and explicitly notes it's branch-agnostic, which distinguishes it from branch-specific siblings like read_branch_context.
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 implies usage when project-level context independent of branch is needed, but does not name alternative tools or explicitly state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool 'Shows prompts and questions' (indicating an informational/read-only nature) and imposes a sequencing rule. However, it does not explicitly state whether the tool has side effects, whether it modifies state, or what exactly the returned guidance looks like beyond 'prompts and questions.' This is a partial but not complete disclosure.
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 primary purpose, and each sentence adds value (purpose + content + sequencing). No filler or unnecessary details; it is appropriately concise.
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?
For a simple 3-parameter tool with a rich enum and no output schema, the description adequately covers the core behavior and a critical prerequisite. It could add more detail about return format or prerequisites (e.g., that an analysis must already exist), but given the tool's simplicity, it is reasonably 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?
The input schema has 100% coverage with clear descriptions for all three parameters, including an enum for 'step.' The description adds no extra semantic value for parameters beyond what the schema already provides, so the baseline of 3 is appropriate.
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 function with a specific verb ('Request') and resource ('detailed guidance for a specific synthesis step'). It also names the direct sibling 'complete_synthesis_step' to differentiate the tool's role, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear and explicit usage constraint: 'Must be called BEFORE complete_synthesis_step for that step.' This gives a specific 'when' and identifies the adjacent tool. However, it does not discuss alternatives or when not to use the tool, so it falls short of full 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 exist, so the description must disclose behavior. It reveals the tool performs a write operation ('place content') and mentions 'safe conflict resolution' as a behavior, but omits concrete details such as backup creation, preview mode, or what 'safe' means in terms of specific conflict strategies. This is minimal but not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the core action, destination, and a key behavior. No filler words; every phrase contributes meaning.
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?
For a 4-parameter import tool with no output schema, the description covers the essential purpose and destination. Optional behaviors like preview and backup are fully documented in the schema, so the high-level description plus detailed schema is sufficiently 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%, and the schema provides clear descriptions for all parameters including zipPath, previewOnly, createBackup, and conflictStrategy. The description adds no parameter-specific meaning, which is acceptable given the schema's completeness.
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?
Description uses a specific verb ('Import') and identifies the resource ('shared context package') and destination ('Cursor-Cortex storage locations'). It clearly distinguishes from inverse tools like generate_context_zip and other context-manipulation siblings.
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 context is clear: this tool is for importing context packages. However, it does not explicitly reference alternatives or exclusionary conditions, such as when to use migrate_context_files instead. Still, the intended usage is immediately apparent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It states 'Shows titles only for better performance and readability' and 'Returns scalable timeline with titles instead of full content', which are key behavioral traits. The term 'Extracts' implies a non-destructive read operation. It doesn't mention side effects, but for a read-only analysis tool the disclosure is adequate.
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 compact and front-loaded with the core purpose. However, it includes 'Phase 2.2' and 'OPTIMIZED' which are process labels and not tool behaviors, adding minor noise. The remaining content is efficient and organized into three concise sentences.
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?
For a tool with six optional parameters and no output schema, the description covers the main behavioral aspects: what data it extracts, the output format (titles only), and date filtering shortcuts. It doesn't explain all possible parameter combinations, but since there are no required params and the schema is self-documenting, the description is sufficiently complete for effective tool selection.
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 six parameters thoroughly. The description adds context about 'Smart date filtering with shortcuts available,' which complements the schema's examples ('7d', '30d', '90d') but does not significantly enhance understanding of individual parameters. Baseline 3 applies because the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 function: 'Extracts chronological timeline data from branch notes and commit separators for reality sync analysis.' This is a specific verb-resource pair that distinguishes it from sibling tools like read_branch_notes or search_branch_notes, which focus on raw note content rather than timeline construction.
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 indicates the tool is for 'reality sync analysis' and is labeled 'Phase 2.2', suggesting a specific workflow step. However, it does not explicitly name alternative tools or state when to use them instead. The context implies this is for chronological reconstruction, which is a clear use case, but lacks explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly discloses the key non-mutating behavior ('without updating the ticket'), which is critical for an agent to understand that this tool has no side effects on the ticket. It does not mention other behaviors like output format or data dependencies, but the core safety-relevant trait is covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the action and object. Every word earns its place, and there is no superfluous information. It is an excellent example of conciseness.
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?
For a simple generation tool with no output schema and no annotations, the description is mostly complete: it states the purpose, the object, and the crucial non-mutation behavior. The only minor gap is that it does not describe the nature of 'the changes' (e.g., derived from branchName) or the comment's format, but these are not essential for selection and invocation given the clear schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters are already well-documented in the schema. The description adds no additional parameter-specific meaning beyond the overall context of 'about the changes', which is not explicitly linked to branchName or projectName. The baseline of 3 is appropriate since 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 tool's function with a specific verb ('Generate a comment') and resource ('Jira ticket'), and adds the key scope qualifier 'without updating the ticket', which distinguishes it from any tool that would actually post or modify the ticket. This makes 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage by emphasizing that the tool generates a comment without updating the ticket, implying it is for producing draft content rather than applying changes. However, it does not explicitly name alternative tools or state 'use this when...' but the 'without updating' phrasing effectively indicates when not to use it for direct modification.
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 the grouping logic and the filtering behavior of maxItems, but it does not explicitly state read-only safety, the structure of the returned data, or potential performance implications of listing across all projects. For a read-only list tool, this is adequate but not richly transparent.
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 with no wasteful words. The first sentence front-loads the core operation and grouping logic, and the second sentence efficiently conveys a parameter tip. Every phrase earns its place.
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?
With no output schema, the description must convey the return structure. It provides a clear outline ('grouped by branch with priority order') and covers the key filtering behavior. It does not detail the exact format of each note, but for a listing tool this is reasonably complete given the schema describes the parameters.
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?
Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the purpose of maxItems ('only include the most recently modified note files (reduces noise)'), which gives context not present in the schema. Other parameters (includeEmpty, currentProject) are only described in the schema, but the added semantic for maxItems justifies a 4.
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 a specific verb ('List'), the resource ('all branch notes across all projects'), and a distinctive grouping behavior ('grouped by branch with priority order (main, stage, then alphabetically)'). This distinguishes it from sibling tools like read_branch_notes or search_branch_notes.
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: for a comprehensive, project-wide listing of branch notes. It also gives a parameter-specific guideline ('Use maxItems to only include the most recently modified note files (reduces noise)'). However, it does not explicitly mention alternatives or exclusions (e.g., when to use search_branch_notes instead), so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses key behaviors: enforces completion of all six perspectives, allows multiple steps, and returns an analysis ID. It does not mention permissions or reversibility, but the core behavioral traits are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with front-loaded action. The first sentence states the primary purpose; the second adds process and output context. No wasted words.
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?
The tool has no output schema, so the description appropriately states the return value (analysis ID). It explains the enforcement behavior and multiphase nature, which is sufficient for initial use. Sibling tools for status and perspective addition provide further workflow context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter is documented in the schema. The description adds little beyond mentioning the returned analysis ID (matching 'analysisId'), but does not compensate for anything missing. Baseline 3 is appropriate.
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 a specific action ('Create a new critical thinking analysis workspace') and a specific methodology ('Six Thinking Hats'). It distinguishes itself from siblings like 'request_synthesis_space' and 'add_perspective' by being the initiating step for a six-perspective process.
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 implies usage as the entry point for a systematic analysis process ('starts a multi-step systematic analysis process'). It provides clear context for when to use it, though it does not explicitly mention alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the critical precondition (guidance must be requested) and the consequence of not meeting it (tool will fail), which is significant. It does not mention other side effects, but the most important behavioral trait is disclosed.
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 exceptionally concise: two sentences, the first stating the core purpose and the second stating the necessary precondition. There is no redundant information or filler, making it highly scannable.
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?
The tool is part of a multi-step process, and the description effectively situates it (after request_thinking_guidance) while noting the failure mode. Since there is no output schema, the description need not explain return values, but it could provide slightly more context about what constitutes a valid analysis; however, the schema parameter descriptions likely cover that.
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 already describes all four parameters with 100% coverage, including a descriptive enum for 'perspective'. The description adds no additional parameter-level detail, but it does reinforce that the operation is tied to a specific perspective and depends on prior guidance, which is a workflow nuance rather than parameter semantics.
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 action ('Add') and the resource ('a specific Six Thinking Hats perspective analysis') within a defined workspace. It distinguishes this tool from sibling request tools by indicating it is the follow-up action after requesting guidance, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly specifies the prerequisite (calling request_thinking_guidance) and the failure behavior if that is not done, providing clear when-to-use guidance and naming the relevant alternative tool. This leaves no ambiguity about the tool's role in the workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool shows thinking prompts and questions, and it exposes the ordering constraint relative to add_perspective. However, it does not explicitly state whether the operation has side effects or is read-only, though 'shows' implies it.
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 primary purpose, and includes the essential prerequisite in the second sentence without wasted words. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a guidance tool with no output schema, the description sufficiently explains what it does, what it returns (prompts and questions), and the required ordering. It lacks detail on error handling or exact return format, but given the simplicity of the tool, it is complete enough.
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 already describes all three parameters (analysisId, projectName, perspective) with 100% coverage. The description adds minor context by referring to 'that hat color' linking to the perspective parameter, but does not add significant semantic value beyond what the schema provides.
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 requests Six Thinking Hats guidance for a specific perspective, and mentions it shows thinking prompts and questions. It also distinguishes from siblings by stating it must be called before add_perspective, clarifying its role as a preparatory step.
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?
It explicitly instructs that it must be called before add_perspective for the same hat color, providing clear timing and differentiation from the sibling tool. This gives an explicit when-to-use and references an alternative.
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-cortex MCP server](https://glama.ai/mcp/servers/flores-ac/cursor-cortex/badges/card.svg)](https://glama.ai/mcp/servers/flores-ac/cursor-cortex)

Score Badge

Copy to your README.md:

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

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/flores-ac/cursor-cortex'

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