Geond Agent Protocol

Server Quality Checklist

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

Latest release: v0.1.1
Disambiguation5/5
Each tool has a clear and distinct purpose, with detailed descriptions that differentiate them. Even closely related tools (e.g., reserve_files vs reserve_symbols) target different resource types, and operations like record, list, close are clearly separated. There is no ambiguity between tools.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case (e.g., close_handoff_summary, get_active_reservations, record_changeset). The verbs describe precise actions, and nouns specify the target resource, making the naming predictable and intuitive.
Tool Count4/5
With 30 tools, the server covers a broad domain including handoffs, reservations, changesets, code graph, workspace management, and activity logging. While the count is on the higher side, each tool serves a distinct operational need, and the number is justified by the scope of the protocol.
Completeness4/5
The tool set covers most lifecycle operations for the domain: CRUD for handoffs (create, list, close), reservations (create, release, renew, list), changesets (record, retrieve), and workspace configuration (get, set). Minor gaps exist (e.g., no explicit update handoff or delete workspace), but these are not critical for the intended agent coordination use case.
Average 4.4/5 across 30 of 30 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 46 commits in the last 12 weeks
- Last stable release on June 3, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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.
This repository includes a glama.json configuration file.
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.
View related servers

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

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 states side effects are limited to database reads, describes output fields, and notes failure mode returns empty list. It is transparent, though it could mention ordering or pagination behavior beyond the limit parameter.
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 well-structured with clear labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). It is concise with no extraneous words, and easily 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?
Given the tool's simplicity (3 optional parameters, output schema exists), the description covers purpose, usage, inputs, side effects, output, and failure modes adequately. It does not explain the output schema content in detail, but that is provided by the schema itself.
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 baseline is 3. The description paraphrases the three parameters (workspace filter, status filter, limit) but does not add new meaning or clarify usage 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 tool's purpose as retrieving handoff packets for a workspace or across workspaces, using a specific verb and resource. However, it does not explicitly differentiate from sibling tools like close_handoff_summary or record_handoff_summary, which would enhance distinguishing value.
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 explicit guidance on when to use the tool: resuming a task, auditing pending work, or preparing context for another agent. It lacks explicit when-not-to-use scenarios or alternatives, but the provided context is clear and helpful.
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 covers side effects (creates rows and audit events), output (status and conflicts), and failure modes (strict policies). Could mention idempotency or locking behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Structured with clear sections (Purpose, When to use, Inputs, etc.), concise with 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?
Given output schema exists, description covers key aspects: purpose, usage, side effects, failure modes. Could mention workspace scoping or permissions.
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 baseline is 3. The description lists parameters but adds little nuance beyond the schema's existing 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?
Clearly states the tool reserves files for coordination, distinguishing it from siblings like release_reservation or reserve_symbols. However, it does not explicitly mention alternatives.
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?
Provides explicit 'when to use' guidance (before modifying files that another agent might touch) but does not discuss when not to use or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full responsibility. It explicitly states 'Side effects: none beyond database reads' and 'Failure modes: returns sparse sections for a new workspace,' which gives the agent a clear behavioral model. This exceeds what is necessary.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly structured with labelled sections (Purpose, When to use, Inputs, etc.) and consists of five concise sentences with 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?
Given the complexity of a dashboard tool, the description covers purpose, usage context, inputs, side effects, output components, and failure mode. It omits potential details like authentication or performance, but is reasonably complete for a read-only 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 the baseline is 3. The description merely restates the inputs ('workspace_id and limit') without adding any additional semantic context or constraints beyond the schema fields.
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 returns a 'compact read-only dashboard summary for one workspace' with a specific verb and resource. However, it does not explicitly differentiate from siblings like get_active_reservations or list_handoff_summaries, though their purposes are distinct.
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?
Provides explicit context: 'call when a human reviewer, PM agent, or orchestrator needs current state without reading raw transcripts.' This clearly indicates when to use, but lacks guidance on when not to use or specific alternatives among the many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It mentions side effects ('creates symbol reservation and audit rows') and failure modes ('strict policy may reject conflicting symbols'). However, it does not disclose whether the operation is destructive or idempotent, nor details on concurrency behavior. This is adequate but not comprehensive.
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 structured into labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes), making it easy to scan. It uses only 5 short sentences, each earning its place with specific information. No fluff.
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?
Given the presence of an output schema (as indicated by context), the description adequately covers inputs, side effects, and failure modes. It provides expected output 'reservation status and conflicts.' For a tool with 6 parameters (3 required), this is sufficient context for an agent to understand usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description lists the input parameters but adds limited new meaning beyond the schema. It does clarify the purpose of 'override_reason' ('reason for overriding a conflict when policy permits overrides'), which adds some value. Overall, minimal extra 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 explicitly states 'Reserve functions, classes, or other symbols for finer-grained parallel coordination.' This clearly identifies the verb (reserve) and resource (symbols), and distinguishes it from sibling tools like 'reserve_files' which operates at file-level.
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 includes a 'When to use' section: 'call before editing shared APIs where file-level reservation is too broad.' This provides clear context for when the tool is appropriate, implicitly contrasting with file-level reservation. It does not explicitly state when not to use, but the guidance is strong enough for a score of 4.
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?
Since no annotations are provided, the description carries the full burden. It states 'Side effects: none beyond database reads' and 'Failure modes: returns an empty event list when no activity matches,' adding valuable behavioral context about safety and error cases.
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 uses clear section headers (Purpose, When to use, Inputs, Side effects, Output, Failure modes) and is very concise. Every sentence adds value, and it is front-loaded with the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, 1 required) and existence of an output schema, the description covers purpose, inputs, side effects, and failure modes. It does not mention sorting or pagination, but for a read tool with an output schema, this is adequate.
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 lists the inputs but adds no additional semantic detail beyond what is in the schema. It does not explain formats, allowed values, or relationships 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 states 'Return normalized activity events for dashboards and orchestrators' with a specific verb and resource. It distinguishes this tool from siblings by listing the event kinds it covers (runs, reservations, handoffs, changesets), making it clear what this tool does compared to more specific tools like get_active_reservations or get_changeset_detail.
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 says 'When to use: call to inspect recent agent runs, reservations, handoffs, changesets, or status transitions,' providing clear context. However, it does not explicitly state when not to use this tool or name alternative tools, so it lacks explicit 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?
Discloses side effects ('writes an activity row') and failure modes ('fails when the workspace id is invalid'), which is useful since no annotations are provided. Could expand on other side effects like permissions or rate limits.
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 uses labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes) which is highly structured and front-loaded. Every sentence adds value with no redundant text.
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?
Covers purpose, usage, inputs, side effects, output, and failure modes. For a logging tool with good schema coverage, this is nearly complete. Could mention what the returned action_id format is or any constraints on the action_type.
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 description adds minimal value beyond listing inputs. It notes that some parameters are optional, but this is already implied by 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 explicitly states 'Purpose: Log what an agent is doing in a workspace.' It uses a specific verb ('log') and resource ('agent action'), and clearly distinguishes from sibling tools like 'record_changeset' which log different entities.
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?
Provides explicit timing guidance: 'call at the start or end of meaningful work so other agents can see active intent and progress.' Though alternatives aren't mentioned, the purpose is distinct enough that this suffices.
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 mentions side effects ('updates workspace policy') and failure modes ('invalid policy names are rejected'), providing useful behavioral context beyond the obvious mutation.
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 well-structured with labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence is concise and necessary, making it easy to scan.
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 setter tool with 2 parameters and an output schema, the description adequately covers inputs, side effects, output, and failure modes. It could mention prerequisites or authorization, but overall 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?
Schema description coverage is 100%, so the baseline is 3. The description paraphrases the parameter descriptions ('workspace_id_or_uri identifies the workspace; reservation_conflict_policy chooses advisory, strict, or override-with-reason') without adding new meaning.
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 explicitly states the purpose: 'Configure how the workspace handles reservation conflicts.' This is a specific verb+resource combination, clearly distinguishing it from sibling tools like get_workspace_coordination_policy (read) and reservation management tools.
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 'When to use' section provides clear context: 'call during setup or team policy changes before multiple agents edit in parallel.' It does not explicitly mention alternatives or when not to use, but the sibling tool 'get_workspace_coordination_policy' serves as a natural alternative for reading.
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 states side effects ('writes fingerprint rows'), output ('stored fingerprint records'), and failure modes ('fails when the workspace cannot be resolved or fingerprint payloads are malformed'). This covers key behavioral aspects, though details on auth, rate limits, or idempotency are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured, using labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence is informative and earns its place, with crucial information front-loaded.
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?
Given the tool's simplicity (2 parameters, no nested objects) and the existence of an output schema, the description covers all essential aspects: purpose, usage context, side effects, output, and failure modes. Nothing critical is omitted.
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 the baseline is 3. The description adds minimal extra meaning beyond the schema: it rephrases 'workspace_id_or_uri' as 'selects the workspace' and 'fingerprints' as 'typed identity facts'. This provides slight additional context but does not significantly enhance understanding beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific verb 'store' and resource 'durable repository identity fingerprints' along with the purpose 'for alias detection'. It effectively distinguishes this tool from siblings like 'suggest_workspace_aliases' and 'register_workspace_alias' by focusing on storing fingerprints rather than aliases.
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 explicit when-to-use guidance: 'call after discovering git remotes, first commits, or other stable repo identifiers on a workspace.' This is clear and contextual, though it does not include explicit when-not-to-use or alternative tool references, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It discloses side effects ('records an MCP audit event'), output format ('compact review context with risks, reservations, handoffs, and lineage'), and failure modes ('returns limited context when workspace history is sparse'). This is comprehensive behavioral 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 structured with clear bullet points (Purpose, When to use, Inputs, Side effects, Output, Failure modes). It is concise and front-loaded with essential information, every sentence adds value.
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?
Given that an output schema exists (context signal), the description does not need to detail return values. It covers purpose, usage, inputs, side effects, and failure modes, making it fully complete for an agent to understand and invoke the tool correctly.
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 description adds minimal extra meaning beyond listing input names ('workspace, intent, optional file paths, symbols, agent name, and limit'). Baseline 3 is appropriate as 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 purpose: 'Summarize relevant reservations, handoffs, lineage, and recent activity before work starts.' It uses a specific verb ('summarize') and resource ('workspace context'), and distinguishes from sibling tools by emphasizing its role as the initial review to avoid duplication or conflict.
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?
Explicitly says 'call at the beginning of a task to avoid duplicating or conflicting with other agents,' providing clear when-to-use guidance. It does not specify when not to use or name alternatives, but the context with siblings makes the usage clear.
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?
No annotations are provided, so the description carries full weight. It discloses side effects (records an MCP audit event) and failure modes (invalid mode raises error, vector/hybrid require embedding provider and database connectivity). It does not explicitly state read-only nature but 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 highly structured with clear sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Each sentence serves a purpose, and the content is front-loaded and efficient.
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?
Given the presence of an output schema (not shown but indicated), the description does not need to explain return values. It covers purpose, usage, inputs, side effects, and failure modes comprehensively for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description groups parameters (query, mode, filters, rerank) but adds only incremental value beyond the schema. It does not provide new details for individual parameters except high-level context.
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 searches imported agent transcripts, changesets, and shared development memory for evidence. It uses a specific verb ('search') and resource, and the sibling tools do not overlap in functionality, making it well-differentiated.
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 says when to use: before editing, reviewing, or explaining repo behavior to reuse prior context. While it does not mention when not to use or alternatives, the context is clear and actionable.
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?
No annotations are provided, so the description carries full burden. It accurately states 'Side effects: none beyond database reads' and describes output and failure modes. Could mention authorization needs, but common sense suffices.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a clear bullet-point structure. Each section is one sentence, front-loading critical information with no fluff.
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 that an output schema exists, the description provides sufficient context about the tool's behavior and output structure. Could mention if there is pagination, but likely not needed for this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both parameters described in schema). The description only names the parameters without additional semantics, so it adds minimal value beyond the schema.
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 purpose as 'Read current file reservations for a workspace' with specific verb and resource. It distinguishes from sibling tools that modify reservations (e.g., reserve_files, release_reservation).
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?
Explicitly says 'call before editing or reviewing files to detect coordination conflicts', providing clear when-to-use guidance. Inputs are summarized (workspace_id and optional file_paths filter).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully covers behavioral traits: side effects ('none beyond database reads'), output details (file locations, workspace data, related changesets, evidence refs), and failure modes ('returns an empty list when the code graph has not indexed the symbol'). This is comprehensive.
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 well-structured with labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). It is concise but not overly terse; every section adds value. Could be slightly more compact without losing clarity.
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?
Given the presence of an output schema and the tool's straightforward nature (lookup by symbol), the description covers all essential aspects: purpose, usage context, inputs, side effects, output, and failure modes. It is fully complete for an agent to understand invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description's explanation of parameters ('symbol is the name to match; limit caps returned entities') adds minimal meaning beyond the schema descriptions, which already define the parameters adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'find' and the resource 'code graph entities', and specifies matching by symbol name. It distinguishes itself from sibling tools like explain_change and get_changeset_detail, which focus on changes or workspace data, by focusing on code graph entity lookup.
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 says when to use: 'call before modifying a function, class, method, or variable so the agent can see definitions and related changesets'. It provides a clear context but does not mention when not to use or alternative tools, which would make it more complete.
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?
Discloses side effects ('updates reservation state and audit events') and failure modes ('returns zero when no matching active reservation exists'). No annotations provided, so description carries full burden. Could mention idempotency but still strong.
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?
Structured with labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence adds value; no redundancy. Front-loaded with most important info.
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?
Covers purpose, usage, inputs, side effects, output, and failure modes. Output schema exists so return values are not needed. Lacks mention of error types or authentication, but still complete for typical agent use.
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% (baseline 3). Description adds relationship: 'workspace_id plus reservation_id or file_path, optionally scoped by agent_name', clarifying alternative inputs beyond the schema's individual descriptions.
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 starts with 'Purpose: Release active file reservations after work is done or abandoned.' Clearly states verb 'release' and resource 'file reservations', distinguishing it from sibling tools like 'reserve_files' or 'release_symbol_reservation'.
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?
Explicit 'When to use' section lists scenarios: handoff, task completion, stale reservation clearance. No explicit when-not-to-use or alternative tool names, but context is clear and covers typical use cases.
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?
Discloses side effects ('updates reservation expiry and audit rows') and failure modes ('returns zero when no matching active reservation exists'). No annotations provided, so description carries full burden; it is sufficiently 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?
Well-structured with headings (Purpose, When to use, Inputs, etc.). No fluff, every sentence adds necessary information.
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?
Covers purpose, usage, side effects, output, and failure modes. Output schema exists, so return details are not needed; description is complete for a renewal tool with 5 params.
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%, baseline 3. Description adds value by summarizing input combinations ('workspace_id plus reservation_id or file_path'), which aids correct usage beyond schema descriptions.
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 'Extend active file reservations while work continues,' which is a specific verb+resource. It distinguishes from sibling tools like reserve_files (creates) and renew_symbol_reservation (symbol-specific).
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?
Explicitly says 'When to use: call before TTL expiry if an agent still owns the edit.' Provides failure mode context but does not explicitly list when not to use or name alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses side effects ('updates handoff status'), output ('count of closed records'), and failure modes ('returns zero when the handoff id does not match an active row'). Good coverage given no annotations provided.
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?
Description is well-structured with clear headings (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence is informative and concise, no wasted words.
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?
Given the tool's simplicity (2 parameters, output schema exists), the description covers purpose, usage, side effects, and failure modes comprehensively. It is complete for the complexity level.
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%, so description adds value by reiterating the purpose of the two parameters and highlighting the default status. The failure mode note provides additional context.
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 clearly states 'Mark a handoff as consumed or no longer active', which is a specific verb and resource. It distinguishes from sibling tools like record_handoff_summary and list_handoff_summaries.
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?
Explicitly states when to use: 'call after the receiving agent has acted on the handoff or a human has reviewed it'. No explicit alternatives mentioned, but the context from sibling tools provides distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It explicitly states 'Side effects: none beyond database reads,' 'Output: current conflict policy and related coordination settings,' and 'Failure modes: fails when the workspace cannot be resolved.' This fully discloses behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with clear labels (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence adds value with no redundancy. It is well-structured and easy to scan.
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 simple tool with one parameter and an output schema, the description covers all necessary aspects: purpose, usage context, input, behavioral side effects, output, and failure modes. No gaps remain.
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 says 'Inputs: workspace_id_or_uri identifies the workspace.' This adds minimal meaning beyond the schema's description ('Workspace UUID, root URI, or alias URI whose policy should be read.'). Baseline 3 is appropriate due to high 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 explicitly states 'Purpose: Read reservation and conflict policy for a workspace.' It uses a specific verb ('read') and resource ('reservation and conflict policy'), and clearly distinguishes from sibling tools like 'set_workspace_coordination_policy' and reservation tools.
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 says 'When to use: call before reserving files or symbols in a multi-agent workflow.' This provides clear context and timing, but does not explicitly state when not to use or list alternatives. However, it effectively guides the agent to use this tool before reservation actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully carries the burden. It discloses no side effects beyond reads, mentions failure modes (sparse graph for new workspaces), and implies read-only behavior. This is comprehensive for a graph-returning 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?
Extremely concise with bullet-like 'Purpose', 'When to use', 'Inputs', 'Side effects', 'Output', 'Failure modes'. No fluff, easy to scan, and each section serves a clear purpose.
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?
Given the tool's complexity (graph output), the description covers inputs, side effects, output format, and failure modes. Output schema exists so return values are defined elsewhere. No gaps remain.
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 baseline is 3. Description merely lists parameters without adding new semantics beyond what the schema already provides. No format constraints or interaction notes are given.
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 clearly states it returns a graph of major collaboration artifacts for a workspace. The verb 'return a graph' is specific and the resource 'major collaboration artifacts' is well-defined. It distinguishes from siblings like get_active_reservations or get_dashboard_overview which focus on specific items rather than a holistic graph.
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?
Explicitly states when to use: when a high-level map is needed. It does not explicitly exclude scenarios or name alternatives, but the purpose is clear enough for an agent to infer appropriate usage. Sibling tools exist for more specific queries, but no contrast is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description provides side effects ('none beyond database reads'), output types, and failure modes, fully disclosing behavioral traits.
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 well-organized into labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes), making it easy to parse and front-loads key information.
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?
Given the tool has an output schema, the description appropriately covers purpose, usage, side effects, and failure modes, leaving no critical gaps for an audit list operation with optional parameters.
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 detailed descriptions. The description merely summarizes inputs ('optional workspace, reservation kind, action filter, and limit') without adding new semantic meaning beyond the schema.
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 states 'Inspect audit history for reservation lifecycle events' with a specific verb and resource, clearly distinguishing it from sibling tools focused on reservation creation, release, or renewal.
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?
Explicit 'When to use' section lists specific scenarios (conflict analysis, stale reservation cleanup, team coordination review). It lacks explicit 'when not to use' but provides clear context.
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?
No annotations are provided, so the description must cover behavioral traits. It mentions 'Side effects: writes changeset and file rows' and 'Failure modes: raises when no workspace identifier is supplied or payloads are invalid,' which discloses key behaviors beyond what the schema conveys.
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 well-structured with labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence provides essential information without redundancy, making it concise and efficient.
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?
Given 11 parameters and moderate complexity, the description covers purpose, usage timing, side effects, failure modes, and input overview. An output schema exists (context signals indicate true), so the description does not need to detail return values, yet it still mentions 'Output: changeset identifiers and summary fields.' This is complete for the agent to decide and invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so baseline is 3. The description adds value by summarizing the inputs: 'files contains changed file objects; workspace_id or workspace_uri is required; metadata links commits, branches, intent, and sessions,' clarifying relationships and requirements.
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 starts with 'Purpose: Persist a code changeset with files, optional patches, git metadata, and session links,' clearly stating the verb (persist) and resource (code changeset). It distinguishes from siblings like 'get_changeset_detail' and 'explain_change' that 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says 'When to use: call after an agent edits or reviews files so future agents can understand what changed and why,' providing a clear context. However, it does not explicitly mention when not to use or name alternative tools for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description fully covers behavioral traits: 'Side effects: writes a handoff row', 'Output: handoff_id for future retrieval', and 'Failure modes: invalid workspace or malformed list fields are rejected'. This is comprehensive 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with clear bullet points (Purpose, When to use, Inputs, Side effects, Output, Failure modes) and is very concise. Every sentence adds value and is front-loaded.
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?
Given the 11 parameters with 100% schema coverage and existence of an output schema, the description covers purpose, usage, side effects, output, and failure modes. Nothing essential is missing.
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 baseline is 3. The description lists input parameters but does not add meaning beyond the schema's descriptions. No examples or formatting hints are provided.
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 'Store a structured handoff packet for the next agent or human reviewer' with specific verb and resource. It distinguishes from siblings like close_handoff_summary and list_handoff_summaries through its unique write operation.
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 'call when pausing, finishing, or transferring a task' providing clear context. It does not mention when not to use or name alternatives, but the context is specific enough for an agent to decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description compensates fully. It discloses side effects ('writes or replaces code graph reference rows'), output shape ('import counts and status'), and failure modes ('malformed reference payloads or invalid workspace ids are rejected'). This is comprehensive and does not contradict any annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with clear headings (Purpose, When to use, Inputs, Side effects, Output, Failure modes) and each section is a single concise line. There is no redundant or extraneous content.
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?
Given the tool complexity (3 parameters, output schema exists), the description covers all necessary context: purpose, usage timing, inputs, side effects, output summary, and failure modes. No gaps remain for an AI agent to decide or invoke the tool correctly.
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-described (e.g., workspace_id: 'Workspace UUID receiving LSP reference edges'). The description only lists the parameter names, adding no new semantics beyond what the schema provides. Baseline 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 purpose: 'Import language-server reference edges into the code graph.' It uses a specific verb and resource, and distinguishes from sibling tools that record other types of data (e.g., record_agent_action, record_changeset).
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 explicit guidance: 'call after collecting definitions or references from an external LSP client.' This clarifies when to use the tool, though it does not explicitly mention when not to use it or provide alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden and excels. It explicitly lists side effects ('writes an alias row'), output ('alias record details'), and failure modes ('fails if the referenced workspace cannot be resolved or the alias conflicts'), providing comprehensive 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear headings (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence serves a purpose, and it is front-loaded with the most critical information. No unnecessary words.
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?
Given the tool's complexity (4 parameters, no nested objects) and presence of an output schema, the description covers all necessary aspects: purpose, usage context, input details, side effects, output, and failure modes. It is fully sufficient for an agent to use correctly.
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 already described. The description's 'Inputs' section adds minimal value beyond grouping (e.g., 'reason and metadata document why it changed'), but does not provide details not already in 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 explicitly states the purpose: 'Link a moved or renamed workspace URI to an existing workspace record.' This is a specific verb-resource combination that clearly distinguishes it from siblings like list_workspace_aliases and suggest_workspace_aliases.
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 'When to use' section provides clear context: 'call when the same repository appears under a new local path, mount point, or machine-specific URI.' While it does not explicitly mention when not to use or alternative tools, the guidance is specific and actionable.
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 full burden. It states 'Side effects: updates reservation state and audit rows,' which discloses mutability. 'Output: count of released symbol reservations' and 'Failure modes: returns zero when no matching reservation exists' further clarify behavior. Missing details like permissions or reversibility, but sufficient 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 uses structured headings (Purpose, When to use, Inputs, Side effects, Output, Failure modes) and is extremely concise. Every sentence is informative with no redundancy. Front-loaded with the core action.
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?
Given 4 parameters, no annotations, and an output schema, the description covers purpose, usage context, input grouping, side effects, output format, and failure conditions. It is fully sufficient for an agent to understand the tool's role and limitations without additional context.
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% with individual descriptions. The description adds semantic grouping: 'workspace_id plus reservation_id or symbol, optionally scoped by agent_name,' clarifying that reservation_id or symbol are alternatives and agent_name is a scope filter. This adds value beyond the flat schema descriptions.
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 states 'Purpose: Release active symbol reservations.' This is a specific verb+resource. It distinguishes from sibling tools like 'release_reservation' and 'renew_symbol_reservation' by focusing on symbol reservations and mentioning use after finishing work on functions, classes, or APIs.
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?
'When to use: call after finishing work on a function, class, API, or other reserved symbol.' gives clear context and timing. It does not explicitly mention when not to use or name alternatives, but the failure mode mention ('returns zero when no matching reservation exists') provides guidance on outcome. Sibling differentiation is implied but not explicit.
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 discloses side effects ('none beyond database reads') and failure modes ('returns an empty list when no fingerprints overlap'). This provides sufficient transparency for safe use.
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 structured with labeled sections (Purpose, When to use, Inputs, etc.) and is concise with no redundant information. Every sentence adds value.
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?
Given the tool's simplicity (2 params, no nested objects) and presence of an output schema, the description covers purpose, usage, side effects, output, and failure modes comprehensively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the schema: 'alias_uri is the new path; fingerprints are observed durable identifiers.' This clarifies the nature of the parameters, especially 'fingerprints' as durable identifiers. Schema coverage is 100%.
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: to suggest existing workspaces that may match a new alias URI based on identity fingerprints. This distinguishes it from sibling tools like 'list_workspace_aliases' and 'register_workspace_alias'.
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 explicit guidance on when to use: 'call before creating a new workspace for a repo that may have moved.' This gives clear context, though it does not explicitly mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden. It states 'Side effects: none beyond database reads' and details failure modes ('returns found=false' and 'ambiguous=true'). It also outlines output fields, ensuring the agent understands the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with clear section headers (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence is essential, and there is no redundancy or wasted words.
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?
Given the tool's moderate complexity (2 parameters, output schema exists), the description is complete. It covers purpose, usage context, side effects, failure modes, and output overview, leaving no gaps for an agent to make incorrect assumptions.
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 value by clarifying that changeset_ref accepts 'UUID, full git SHA, or unambiguous SHA prefix' (more specific than schema's 'commit prefix') and that include_narrative 'controls cited prose' (adds nuance beyond schema's description).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Retrieve full stored detail for one changeset', using a specific verb and resource. It clearly distinguishes from sibling tools like explain_change or get_symbol_context, none of which retrieve full changeset details.
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 includes a 'When to use' section that explains the context: call after a search returns a changeset ID or git commit needing closer inspection. This provides clear guidance, though no explicit when-not or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description fully discloses behavior: safe, read-only, no database connection, no reading of transcripts, and no side effects.
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 with labeled sections (Purpose, When to use, etc.), and every sentence adds distinct value without redundancy.
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 no-parameter info tool with an output schema, the description lists output contents and failure modes, making it complete.
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?
No parameters exist, and the description correctly notes 'Inputs: none', meeting the baseline expectation for 0-parameter tools.
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 'Return' and resource 'safe, read-only summary of the Geond Agent Protocol MCP server', and its purpose is distinct from sibling tools that handle reservations, changesets, etc.
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?
Explicit directive 'Call this first' for understanding Geond before connecting to PostgreSQL provides clear context, though no exclusion cases are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description fully discloses side effects ('none beyond database reads'), failure modes ('returns empty list when no active conflicts'), and output fields. This provides comprehensive behavioral insight beyond what annotations would cover.
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 structured into labelled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes) with no redundant sentences. Every element serves a clear purpose.
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?
Given the tool's simple nature (2 params, read-only), the description covers all essential aspects: purpose, usage context, inputs, side effects, output, and failure modes. It is fully sufficient for an agent to use correctly, even without annotations or full output schema visibility.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, but the description adds value by summarizing the parameters and specifying output fields (owners, purposes, expiry). This enhances understanding beyond raw schema definitions.
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 specific verb ('Read') and resource ('symbol reservations that could conflict with planned work'), clearly distinguishing this read operation from sibling tools like get_active_reservations (all reservations) and reserve_symbols (creation).
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?
Explicitly states 'call before changing shared APIs or named entities', providing a concrete usage scenario. Although it doesn't list explicit alternatives or exclusions, the context is clear enough for an agent to infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully covers behavior: 'Side effects: none beyond database reads' and 'Failure modes: returns an empty list when no aliases exist or the filter matches nothing.' This gives clear 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 structured with labeled sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). It is concise and every sentence adds value, with no wasted words.
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?
Given the presence of an output schema, the description appropriately explains the output briefly. It covers purpose, usage, side effects, and failure modes, providing complete context for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers the parameter with a description, and the tool description adds 'workspace_id_or_uri optionally scopes the list.' Since schema coverage is 100%, the description adds marginal value, meriting 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 explicitly states 'Purpose: Inspect workspace alias mappings,' providing a clear verb and resource. It distinguishes from sibling tools like 'register_workspace_alias' and 'suggest_workspace_aliases' by focusing on inspection.
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 gives a specific usage scenario: 'call when an agent is unsure whether two filesystem roots point to the same repository memory.' It does not explicitly list when not to use or alternatives, but the provided guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses side effects ('updates reservation expiry and audit rows') and failure modes ('returns zero when no matching active reservation exists'), which is comprehensive.
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 structured with clear headings (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence serves a purpose, and there is no redundancy.
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?
With 5 parameters and no annotations, the description covers purpose, usage, inputs, side effects, output, and failure modes. The output schema exists but is not needed as the description states the output is a count.
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 baseline is 3. The description adds value by grouping inputs ('workspace_id plus reservation_id or symbol, optional agent_name, and TTL'), clarifying the relationship between parameters beyond the schema.
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 'extend' and the resource 'active symbol reservations', and includes the context 'while an agent is still editing'. This distinguishes it from siblings like release_symbol_reservation or reserve_symbols.
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?
It explicitly says 'call before TTL expiry for ongoing API or function work', providing clear context. It does not explicitly mention when not to use or compare with alternatives, but the guidance is sufficient for typical scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Side effects: none beyond database reads,' and mentions failure modes, covering key behavioral traits beyond the schema.
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 well-structured with clear sections (Purpose, When to use, Inputs, Side effects, Output, Failure modes). Every sentence is informative, and there is no redundancy.
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?
Given the presence of an output schema (indicated in context signals), the description appropriately omits return value details but covers purpose, usage, inputs, side effects, and failure modes, making it fully contextual.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds context: 'file_path identifies the repo-relative file; limit caps evidence volume; include_narrative adds a deterministic cited summary.' This enriches the schema definitions.
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 'Explain why a file may have changed using stored changesets, code graph entries, snapshots, and related messages.' It uses a specific verb and resource, distinguishing it from siblings like get_changeset_detail which focuses on a single changeset.
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 says 'call during code review, bug triage, or handoff recovery when a file path needs historical context.' This provides clear context for when to use the tool, and the failure modes section helps avoid misuse.
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:

[![geond-agent-protocol MCP server](https://glama.ai/mcp/servers/geondongkim/geond-agent-protocol/badges/card.svg)](https://glama.ai/mcp/servers/geondongkim/geond-agent-protocol)

Score Badge

Copy to your README.md:

[![geond-agent-protocol MCP server](https://glama.ai/mcp/servers/geondongkim/geond-agent-protocol/badges/score.svg)](https://glama.ai/mcp/servers/geondongkim/geond-agent-protocol)

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/geondongkim/geond-agent-protocol'

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