@achi/drive-mcp

Server Quality Checklist

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

Latest release: v1.2.0
Disambiguation3/5
Most tools are clearly distinguished by resource type (file, folder, unit, mail, skill), but list_files and list_folder_children overlap significantly since list_files with a parentFolderId already lists immediate children. read_file_text is also a thin wrapper over read_file, adding ambiguity.
Naming Consistency4/5
The naming largely follows consistent patterns (list_*, get_*, read_*, create_*, update_*, delete_*), but there are outliers like whoami, search, restore_unit, and download_unit_document that break the verb_noun convention. Overall, the pattern is predictable despite a few deviations.
Tool Count2/5
With 38 tools, this server is well over the 25-tool threshold for 'too many'. It bundles file storage, mail, property management, and skills into a single server, making it heavy and potentially overwhelming for agents to navigate.
Completeness3/5
File/folder CRUD is complete, and unit management has update, versioning, and document handling. However, there is no create_unit or delete_unit, leaving an obvious lifecycle gap for property management. Mail is intentionally read-only, so that is not a gap.
Average 3.6/5 across 38 of 38 tools scored. Lowest: 1.8/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 9 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does not mention whether the operation is read-only, has side effects, requires permissions, or returns a specific format. The description is silent on all behavioral aspects beyond requiring teamId.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short, but this is under-specification rather than conciseness. The fragment 'Kontoauszug lines for a team space' lacks grammatical completeness and essential context. The second sentence repeats requirement information already in the schema, adding no value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given three parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain the purpose clearly, describe return behavior, or elaborate on parameter semantics. This is completely inadequate for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has three parameters (to, from, teamId) with 0% coverage in the description. The description only says 'Requires teamId,' which is redundant with the schema's required field. It provides no explanation of what 'to' and 'from' represent or any additional meaning for teamId. This fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the resource ('Kontoauszug lines') and scope ('for a team space'), but lacks an explicit verb indicating the action. The tool name implies 'list', but the description itself is a noun phrase, leaving the purpose somewhat ambiguous. It does not clearly differentiate from sibling list tools beyond the specific resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The only usage hint is 'Requires teamId,' which is a parameter requirement rather than situational advice. There is no mention of exclusions, prerequisites, or preferred contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It explicitly warns not to invent missing legal name, street, or IBAN, which is valuable behavioral guidance against hallucination. However, it does not disclose whether the operation is read-only, what the response structure is, or how empty fields are represented beyond the warning.
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 very short and free of fluff; two sentences deliver a resource and a key caution. It is efficient but somewhat fragmentary ('Stored Vermieter letterhead') which slightly reduces clarity. Overall, it earns high marks for not wasting words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get tool with one parameter and no output schema, the description should at least mention what the output represents and how the parameter works. It partially covers the data (letterhead) and includes a warning about empty fields, but omits any description of return format, successful/failed responses, or the role of teamId, leaving it incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention the 'teamId' parameter at all. The parameter name is self-explanatory, but the description fails to connect it to 'a space' or explain how it is used. With no parameter info in the schema, the description should compensate but does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource (Vermieter letterhead for a space) but lacks a clear active verb like 'get' or 'retrieve', making it a noun phrase rather than an explicit action. It does not distinguish itself from sibling tools, many of which are similarly listed as get/list operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool instead of alternatives. It does not mention prerequisites, when not to use it, or how it relates to sibling tools like get_unit or list_units. The single sentence provides no contextual usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It merely restates the tool's function without explaining permissions, idempotency, error scenarios, or what happens on success. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no unnecessary words. It is front-loaded and easy to parse. However, it is almost too minimal, bordering on tautological, but it still earns its place as a clear action statement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has three parameters and no output schema or annotations, and the description does not compensate. It fails to explain the return value, the significance of teamId and parentFolderId, or any side effects. This is completely inadequate for an agent to understand the tool's full behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides descriptions for teamId and parentFolderId, covering 67% of parameters. The description adds nothing about parameters, but the schema sufficiently handles their meaning. Name is self-evident from the context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action with a specific verb and resource: 'Create a new folder.' It is unambiguous and distinguishes from sibling tools like update_folder and delete_folder, though it doesn't explicitly differentiate usage scenarios. For a simple creation tool, this is sufficient.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives or prerequisites. It doesn't mention that teamId or parentFolderId can be used, nor does it compare with list_folder_children or other folder operations. The description offers no context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure, but it only says 'Get metadata for a folder.' It does not describe the return structure, whether the operation is read-only (though 'Get' implies it), or any error conditions. The lack of explicit transparency is a notable gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that conveys the core purpose without any wasted words. It is appropriately sized for a simple operation, though it sacrifices informational depth for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description is too sparse to be fully contextual. It lacks details on return values, typical use cases, and relationships to sibling tools, leaving gaps for the agent. The lack of annotations exacerbates this incompleteness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one required parameter 'id' with format uuid, but no description coverage (0%). The tool description does not explain what 'id' refers to or how it should be used, forcing the agent to rely solely on the schema's format hint. This is insufficient compensation for the lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('metadata for a folder'), making it distinct from sibling tools like get_file or list_folder_children. It is specific and unambiguous, satisfying the criteria for a high score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as get_file or list_folder_children. There is no mention of prerequisites, use cases, or exclusions, so it fails to orient the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses a key safety trait ('Never returns passwords') and implies read-only access. However, it does not mention authentication, return format, or other behavioral details, so transparency is minimal but present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant words. It front-loads the core purpose ('Mailboxes the user can read') and adds a critical safety note. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one optional parameter and no output schema, the description is incomplete. It omits any explanation of teamId and does not clarify how this tool relates to sibling mail tools like search_mail or read_mail. The safety note is useful but insufficient for fully informed invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention the teamId parameter at all. The agent is left without any explanation of what teamId does or when to include it, so the description adds no value for parameter understanding.
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 'Mailboxes the user can read' clearly indicates the tool returns a list of mailboxes the user has access to, matching the 'list' verb in the name. It is not a tautology because it adds access-control context, though it lacks an explicit verb like 'List all mailboxes...'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like search_mail or read_mail. The description does not mention any exclusions, prerequisites, or context for choosing this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits, but it only offers a high-level definition. It does not mention read-only nature, the meaning of the date range, or what the response contains, leaving significant behavioral context unstated.
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, using just two short phrases. Every word adds value and the core purpose is front-loaded, with no wasted verbiage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 3 parameters and no output schema, yet the description does not describe the return structure or how the date range affects results. The purpose is clear, but an agent cannot fully anticipate the tool's behavior from this description alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not explain the from/to parameters or unitId beyond what the schema shows. Schema coverage is only 67% and even those descriptions are just format (YYYY-MM), not semantics, so the description fails to compensate for the gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a bank-statement payment trail for an apartment, specifying cost types (cold/warm/NK). This distinguishes it from generic tools like list_bank_transactions, though it lacks an explicit verb.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Source of rent-paid truth' implies this is the authoritative tool for verifying rent payments, providing implied usage context. However, it does not explicitly mention alternatives or when-not-to-use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It adds useful context: the search scope is limited to readable mail and it reassures that passwords are not included. However, it does not disclose pagination, return format, or authentication needs, leaving significant behavioral aspects unstated.
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: two short sentences that are immediately understandable. 'No passwords.' adds a safety note without unnecessary length. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 5 optional parameters, no output schema, and no annotations, the description leaves the agent without enough information to correctly invoke the tool. It does not explain parameter semantics, return structure, or edge cases. This is far from complete for a search tool with multiple filter options.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 20% (only 'mailbox' has a description). The description mentions subject/from/snippet, which are not parameter names, and does not explain q, limit, teamId, accountId, or how mailbox values behave beyond the schema. It fails to compensate for the low 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 uses a specific verb ('Search') and resource ('mail'), with clear scope ('the user can read') and fields ('subject/from/snippet'). It clearly differentiates from sibling tools like read_mail and the generic search tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear context ('search mail the user can read') but provides no explicit guidance on when to use this instead of sibling tools like read_mail, list_mail_accounts, or search. No exclusions or alternative references are included.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It specifies the scope ('immediate children') but omits other relevant behaviors such as pagination, ordering, whether hidden files are included, or the exact response format.
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?
One clear, concise sentence that immediately states the tool's purpose without filler. It is efficiently front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three parameters, no annotations, and no output schema, the description is too sparse. It omits parameter semantics and key behavioral details like pagination, making it barely adequate for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain the meaning or usage of id, limit, or cursor. It adds no value beyond the bare parameter names and types, leaving the agent to infer semantics from the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and identifies the exact resource ('immediate children (files + subfolders) of a folder'). The qualifier 'immediate' distinguishes it from recursive listing and from sibling tools like list_files or get_folder.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you need to list a folder's immediate children) but does not explicitly mention when to prefer it over siblings like list_files or get_folder. There is no 'use this instead of...' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior, but it only mentions 'Download' and the file types. There is no mention of permissions, return format, or error handling, leaving a significant transparency gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first states the function, the second gives usage rationale. No extra words, front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter download tool, the description is adequate but leaves gaps: 'trail document' is unclear, the return payload is not described, and there's no link to sibling tools like list_unit_documents or get_file.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only names and UUID formats, and the description adds no explanation of what docId or unitId refer to. The phrase 'one trail document' hints at docId but does not clarify the role of unitId, and schema coverage is 0%.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool downloads one trail document (PDF/ODT), using a specific verb and resource type. It also distinguishes it from re-attaching files, which separates it from upload-related siblings, though 'trail' is ambiguous.
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 to use this instead of asking the user to re-attach HV or heating files, which is a clear when-to-use scenario. It doesn't list alternatives or exclusions for other document types, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the burden. It discloses one non-obvious behavior (mid-year move-out yields two rows), which is useful, but it omits other important behavioral details such as auth requirements, response structure, or error conditions. Some transparency exists, but it is limited.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero filler. The edge case is packed into a second sentence efficiently. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema and no annotations, so the description must provide a complete picture. It gives purpose and a nuance, but does not explain what the returned rows contain, how to interpret the two-row case, or whether additional parameters are needed. For a 2-parameter list, this is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only vaguely references 'apartment and year', not mapping to unitId and year. It does not explain what an NK settlement is, or what the year means beyond schema min/max. With no param descriptions in schema, the description fails to compensate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('tenant NK settlements') with clear scope ('for an apartment and year'). The added note about mid-year move-out producing two rows further distinguishes this from a generic list. It is clear even without naming a sibling alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus other tools, no exclusions, and no prerequisites. The edge case about move-out is behavioral, not usage direction. An agent gets no context about when this is the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds a notable disclosure ('No passwords') and specifies the body format ('plaintext'), which provides some behavioral context. However, it does not mention return format, error behavior, or whether reading marks the message as read. With no annotations, the description carries the full burden, and it only partially addresses it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the core action. Every word adds value, and there is no unnecessary elaboration or repetition. It is appropriately concise for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description still leaves important gaps: it does not explain the parameter semantics, usage context relative to siblings, or expected return. The minimal text is not enough for an agent to confidently invoke the tool correctly without additional assumptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one required parameter 'id' with no description, and the tool description does not explicitly explain that 'id' is the mail message identifier. The phrase 'one mail message' implies the need to select a specific message, but the description does not clarify how the parameter is used or formatted. Schema description coverage is 0%, so the description should compensate, but it does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read') and resource ('one mail message') and specifies scope ('one') and content ('including plaintext body'). It clearly distinguishes from siblings like search_mail, which implies a broader search/listing operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is given about when to use this tool versus alternatives. There is no mention of exclusions or prerequisites. The usage is only implied by the verb 'Read', but no context is provided for selection among mail-related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior itself. It indicates a read-only listing operation and provides output context (fileId can be used with read_file), but it does not disclose potential team scoping via teamId, pagination, or error 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 two short sentences that each add value: the first defines the resource and scope with an example, the second gives a clear next step. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool, the description covers the core purpose and a useful follow-up, but leaves gaps: teamId semantics, return format, and the meaning of 'this space' are undocumented. It is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema defines one parameter, teamId, but the description does not mention it at all. With 0% schema coverage, the agent receives no guidance on what teamId means or whether it should be supplied.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action and resource: 'List SKILL.md files mirrored from git folders'. The example 'novel-dialogue' and the distinction from sibling tools like list_git_folders and read_skill make the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the imperative 'List' and offers a workflow hint ('Then read_file on the fileId'), but it does not explicitly state when to prefer this tool over alternatives such as list_files or read_skill, nor any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full transparency burden. It lists the actions but does not disclose behavioral nuances such as whether setting trashed=true moves the folder to trash and trashed=false restores it, what happens to the folder's contents upon trashing, permission requirements, or reversibility of each operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence using clear action verbs. Every word contributes value, and there is zero redundancy. It is an exemplar of conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a multi-operation mutation tool with no annotations and no output schema. The description covers the primary actions but omits important context such as return values, interaction effects (e.g., moving a trashed folder), and edge cases like partial updates. The agent would be underinformed for safe 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 description coverage is 0%, so the description must compensate for missing parameter documentation. It effectively maps each operation to a parameter (rename→name, move→parentFolderId, star/unstar→starred, trash/restore→trashed), adding semantic meaning beyond the bare schema. However, it does not clarify value behavior (e.g., boolean toggles) or parameter interdependencies.
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 enumerates four distinct operations (rename, move, star/unstar, trash/restore) on the folder resource. This makes the tool's purpose unmistakable and differentiates it from sibling tools like update_file, delete_folder, or create_folder.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool—whenever you need to rename, move, star, or trash/restore a folder—but it provides no explicit guidance on alternatives or exclusions. For example, there is no mention that delete_folder handles permanent deletion, which could lead to misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It briefly implies a read-only operation via 'read the Drive copy' but lacks details about output format, authentication specifics, or side effects. The GitHub token directive is more about agent conduct than tool 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?
Two sentences, no redundant wording, and the core purpose is front-loaded. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description captures the primary purpose and a key usage rule, but omits any explanation of the teamId parameter and does not describe the return value format. For a simple listing tool it is partially complete, but these omissions create ambiguity for an agent trying to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter teamId is undocumented in the schema (0% coverage) and never mentioned in the description. The agent has no way to infer what value to pass or whether it filters results. This is a significant gap requiring compensation that does not occur.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists Drive folders that mirror a private git repo, using a specific verb 'List' and a precise resource. It distinguishes itself from sibling tools like list_files or list_folder_children by scoping to git-mirrored folders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The instruction 'Agents read the Drive copy — never ask for a GitHub token' gives clear usage guidance: prefer this tool for git-repo content and do not request GitHub credentials. While it doesn't explicitly contrast with sibling tools, it implies this is the correct option when dealing with git mirrors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavioral traits. It only mentions setting mimeType for 'proper handling' and does not address important behaviors like overwrite policy, permissions, size limits, or return values. This is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise, with exactly two sentences that front-load the core purpose and then provide targeted guidance. Every sentence adds value, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters, no annotations, and no output schema, the description is incomplete. It omits guidance on parentFolderId, teamId, return behavior, failure modes, and other critical context, making it insufficient for a tool with this complexity.
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 67%, so the description adds meaningful semantics beyond the schema. It clarifies content encoding (base64 for binaries, text otherwise) and emphasizes mimeType's role, which compensates for missing parameter descriptions for those fields.
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 'Upload a new file' with a specific verb and resource. It distinguishes from siblings like update_file and delete_file by emphasizing 'new', making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating new files but does not explicitly state when to use this tool over alternatives or provide exclusions. It offers contextual guidance on content encoding but lacks clear 'when-not-to-use' information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It indicates a read-only operation via 'List,' but it does not disclose potential permissions, pagination, or exactly what is returned. It adds modest context by naming document types but lacks deeper behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no filler. It leads with the action and resource, and the parenthetical examples add value without bloat. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter, no output schema, no annotations), but the description still lacks explicit guidance on return format or behavior. It names document types but doesn't clarify whether it returns full documents or metadata, or if any filtering is applied. Given the lack of annotations and output schema, a bit more detail would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only a bare unitId parameter with no description (0% coverage). The description partially compensates by tying it to 'an apartment,' implying unitId is the unit/apartment ID. However, it does not explicitly define the parameter or its format, leaving some ambiguity.
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 the specific verb 'List' with a clear resource: 'Properties document trail for an apartment.' It gives concrete examples (HV, heating, tax, prior NK letters) that distinguish it from general file listing tools. This clearly differentiates it from siblings like list_files or list_unit_versions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for retrieving a unit's document history, but it does not explicitly state when to use it over alternatives or provide exclusions. No alternative tools are mentioned, making usage guidance only implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses a key behavior: the operation is scoped to one settlement and does not affect other tenants. However, it omits other important traits such as permission requirements, reversibility, or any side effects (e.g., notifications or document updates).
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 just two short sentences. The core purpose is front-loaded in the first sentence, and the scoping note in the second adds essential context without any fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 8 parameters, no annotations, and no output schema, the description is insufficient. It leaves critical gaps: how to identify the settlement (unitId/nkId), what the amounts represent, and any side effects or prerequisites. The agent would need to rely on implicit knowledge or external context to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'status, amounts, notes' which groups some parameters, but it does not explain the required identifiers (unitId, nkId) or the meaning of the individual amount fields (balanceEuros, prepaidEuros, totalCostsEuros). The description adds minimal value over the raw 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 uses a specific verb ('Patch') with a clear resource ('one NK settlement') and lists the main fields affected ('status, amounts, notes'). This distinguishes it from siblings like list_nk_settlements (listing) and create_nk_letter (creating a letter).
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 phrase 'Does not change other tenants in the same year' provides a clear scoping guarantee, which helps decide when to use this tool. However, it does not explicitly state when not to use it or name alternative tools, so it falls short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It reveals that the tool mutates a document ('Patch') but doesn't disclose any side effects, permissions, reversibility, or return behavior. The only extra behavioral context is the date format hint, which is more parameter-related.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and target, followed by a practical usage note. No wasted words; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple patch operation with no output schema and no annotations, the description covers the core purpose and a key use case. However, it omits details like what the response contains, whether all fields are optional beyond required ids, and any prerequisites. It is adequate but lacks the richer context an agent might need for error handling or confirmation.
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 low (only documentDate has a description). The description compensates partially by naming the three updatable fields and specifying accepted date formats (YYYY-MM-DD or DD.MM.YYYY). However, it doesn't clarify unitId/docId semantics beyond the schema's type/format, and the documentDate schema description adds extra nuance ('not 31 Dec...'). Overall, it adds some value but not full compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Patch') and the resource ('a trail document'), and lists the specific fields that can be updated (title, documentDate, notes). This distinguishes it from sibling tools like create_unit_document and download_unit_document.
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 gives a concrete use case ('wrong letter date') and a directive ('do not ask the user to edit the UI'), which helps the agent decide when to invoke this tool. It does not explicitly name alternative tools, but the context is 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?
With no annotations, the description carries the transparency burden. It discloses the input method ('Send contentBase64'), the upload destination ('Achi Properties/{unit}'), and the side effect of creating a trail row. It omits details on alternative driveFileId input and permission requirements, but adds meaningful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at three sentences, front-loads the purpose, and avoids excessive detail. It could be more structured to list key parameters, but it remains efficient and scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 13 parameters, no annotations, and no output schema. The description only provides high-level context and one parameter hint. It fails to explain critical aspects like the distinction between contentBase64 and driveFileId, date formats, category handling, or expected response. This is a significant gap for a complex mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 23%, and the description only explains contentBase64 explicitly. Most other parameters (title, periodFrom, documentDate, category, etc.) receive no additional meaning beyond their names. The description does not compensate for the low schema coverage, leaving agents guessing about required formats and relationships.
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 creates a 'Properties trail document' with concrete examples (NK letter, HV file), using the specific verb 'Create' and resource. It distinguishes itself from siblings like list/update/download unit documents by focusing on 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?
Provides a clear usage directive: 'Use this instead of asking the user to re-attach,' signaling when this tool is preferred. It also describes the side effect of uploading into 'Achi Properties/{unit}' to create a trail row. However, it does not explicitly contrast with alternatives like upload_file or update_unit_document.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the authentication requirement ('Requires a content-access token') which is useful. However, it does not describe the return format, whether it returns metadata or content, pagination, or any other behavior beyond listing. It is not misleading, but adds limited 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 two short sentences, front-loaded with the core action and scope, and the token requirement is a concise addition. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool with no annotations or output schema, the description gives the essential purpose and a critical prerequisite. However, it lacks parameter clarification and what the response looks like, making it incomplete for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter (teamId) with zero description coverage. The description does not mention teamId at all, leaving its role ambiguous. It says 'in a space' but does not connect that to teamId, so the agent cannot infer how to specify the space from the 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 clearly states 'List Drive /Agent notes in a space' with specific examples (agent.md, learnings/letters.md), giving a specific verb+resource+scope. It distinguishes itself from sibling tools like list_files and list_folder_children by focusing on Agent notes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (for listing Agent notes specifically) and mentions a prerequisite: 'Requires a content-access token.' It does not explicitly name alternatives or exclusions, but the scope is clear enough to infer its unique purpose among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses visibility filtering and scope semantics, but it does not mention return format, pagination, default behavior with no parameters, or 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences and leads with the core purpose. The parenthetical 'Properties (Vermietung)' is slightly redundant but not a significant issue.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool without output schema or annotations, it covers visibility, team scoping, and scope=all. However, missing default behavior, pagination, and return shape information prevents it from being fully self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero description coverage, so the description must compensate. It adds meaning by explaining teamId as a space identifier and scope=all as listing every space, but it leaves the default behavior and the relationship between the two parameters ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (List) and the resource (Properties/Vermietung apartments), and scopes it to what the user can see. It also distinguishes this general list operation from sibling tools like get_unit by describing its collection-level behavior.
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 provides actionable usage context: pass teamId for a specific space, use scope=all to list every space. However, it does not explicitly mention alternative tools or when not to use this tool, so it stops short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the return value (Drive fileId) and the lookup behavior, but it does not explain the 'mirrored' concept, the effect of teamId, or error/not-found behavior. The parenthetical '(novel-dialogue)' is ambiguous—whether it is an example or a hardcoded value—which slightly undermines 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 exceptionally concise: two sentences, no redundant information, and the core purpose and next step are front-loaded. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one required parameter and no output schema, the description covers the essential purpose and next step. However, it omits teamId and leaves the parenthetical example ambiguous, making it not fully complete. It is adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains the 'name' parameter via 'by name' and provides a sample value, but it says nothing about the optional teamId parameter. Since half the parameters are undocumented, the description falls short for a tool with no 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 tool's purpose with a specific verb ('Find'), a distinct resource type ('mirrored skill'), the lookup criteria ('by name'), and the result ('return its Drive fileId'). It distinguishes itself from siblings like list_skills (which likely lists all) and read_file (which reads a file given its ID).
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 provides a usage context by instructing 'Use read_file next', which tells the agent the natural next step after obtaining the fileId. It lacks explicit alternatives or when-not-to-use guidance, but the workflow hint is clear enough for this focused tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the read-only nature (listing) and ordering ('newest first'), but does not mention pagination behavior, return format, or error conditions. For a list operation, this is acceptable but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences, front-loaded with the core purpose, and every word is useful. It includes an ordering detail and a practical alternative without unnecessary filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list operation with two obvious parameters, the description covers the purpose, ordering, and a relevant alternative. It lacks an explicit return-shape description and does not mention the limit parameter, but overall it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% because the description does not mention either parameter (unitId or limit). Although the parameter names are somewhat self-explanatory, the description adds no meaning beyond the schema, such as the requirement to provide unitId or the role of limit.
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 lists 'Properties unit snapshots' with an explicit ordering ('newest first'). This distinguishes it from the sibling tools like list_units (which lists units) and restore_unit (which restores snapshots).
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 points to restore_unit as the alternative when an earlier write was wrong, giving a clear usage scenario. It does not fully explain when to use list_unit_versions versus list_units, but the term 'snapshots' implies historical versions, offering some implicit differentiation.
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 must carry the full burden of behavioral disclosure. It explains the conditional behavior ('if it has one') and the return type ('MCP image content'), but it does not explicitly state that it has no side effects, nor does it mention error behaviors or access requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that front-load the core purpose, condition, return type, and common use case. There is no redundant or filler wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool, the description covers what it does, the conditional nature of the result, what it returns, and why it's useful. It does not describe error behavior, but the low complexity and the 'if it has one' phrasing mitigate that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'id' is defined in the schema as a uuid but has no description, and the description does not mention it at all. With schema description coverage at 0%, the description should compensate and explain that 'id' refers to the file's identifier, but it does not, leaving room for ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' and explicitly names the resource 'JPEG thumbnail of a file', making it clear this tool is for previewing a file's thumbnail rather than the full file. This distinguishes it from siblings like get_file, read_file, and read_file_text.
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 its practical use case: 'Useful for previewing images/videos without downloading the full file.' This tells an agent when to invoke it over file-download siblings, though it does not mention when not to use it or list alternative tools.
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 transparency burden. It discloses the key behavioral distinction between trash (default, non-permanent) and permanent deletion (irreversible), which is essential. However, it does not mention whether trashed files can be restored or any permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the core behavior and includes the critical default. No filler 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?
For a simple delete operation, the description covers the primary behaviors and outcomes. It doesn't describe return values or recovery from trash, but these are not essential given the tool's simplicity and the context from sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers the 'permanent' parameter with a detailed description, and the tool description reinforces the default. The 'id' parameter is self-explanatory in context. The description adds minimal parameter semantics beyond the schema, but the 50% schema coverage is partially compensated by the explicit default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: moving a file to trash or deleting it permanently, with a clear default. The verb+resource is specific, and the mention of 'file' distinguishes it from folder deletion tools in the sibling list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for deleting files but does not explicitly state when to use it versus alternatives like delete_folder. It provides context about the default behavior but lacks exclusions or alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It notably discloses a data integrity guarantee ('Does not invent Anschrift or IBAN'), which is valuable. Yet it omits other behaviors such as whether the operation is read-only, authentication needs, or error/return behavior beyond the listed fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the main action and a clear list of returned data. The second sentence adds a specific guarantee without unnecessary detail. Every word contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one simple parameter and no output schema, the description adequately covers the tool's purpose, the retrieved fields, and a data-integrity caveat. It is nearly complete for a basic get-by-id tool, though it could explicitly state the return structure or behavior on missing IDs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema defines a single required 'id' as a uuid, and the description does not explicitly mention this parameter, resulting in 0% schema description coverage. However, the tool name and 'Load one apartment' implicitly clarify that 'id' identifies the apartment, providing some semantic context. This partial compensation merits a mid-range score.
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 the verb 'Load' with the resource 'one apartment' and enumerates the returned content (tenant, rent, address, trail folder). The 'Does not invent Anschrift or IBAN' clause further specifies data scope, and the singular focus distinguishes it from list_units.
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 phrase 'Load one apartment' clearly conveys this tool is for retrieving a single unit's details by ID, implying use when you need one unit rather than a list. However, it does not explicitly name alternatives like list_units or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral disclosure burden. It effectively communicates case-insensitive matching, a 5,000-item scan limit per scope, and possible truncation for large drives – all useful 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 two concise sentences with no redundant phrasing. It front-loads the core action and includes essential limitations without clutter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers search semantics and truncation risk, but omits parameter meanings, what defines a 'scope', and how results are returned. Given no output schema and no annotations, additional details would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not explain any of the parameters. The phrase 'by name' implicitly references q, but limit and teamId are left undefined, leaving significant semantic gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool searches files and folders by name using a case-insensitive substring match. This specific verb+resource combination distinguishes it from sibling tools like search_mail and the various list_* browsing 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 implies this is the tool for name-based searching, but does not explicitly state when not to use it or mention alternatives such as list_files or list_folder_children for browsing. The context is clear but lacks exclusionary guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that a snapshot is taken before the write (enabling restore_unit), that versionReason is mandatory, and that ifUpdatedAt is used for optimistic concurrency to prevent clobbering. This is valuable context, but it omits details like partial update semantics, return values, and permission requirements.
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 compact and well-structured: a leading purpose statement, a behavior note (snapshot), and two imperative usage tips. Each sentence earns its place with no filler. Front-loaded with the primary action, it is easy to parse and understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 30 parameters, no annotations, and no output schema, the description covers the most critical operational aspects (snapshot, versionReason, ifUpdatedAt) but omits other important context such as partial vs. full update behavior, what the response contains, and any prerequisites or permission concerns. It is adequate for safe invocation but not fully complete given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 7% (only ifUpdatedAt and versionReason have descriptions). The description names a few fields informally (rent, tenant) that do not directly match the schema fields (rentEuros, tenantName, tenantEmail), which could confuse an agent. It does clarify the purpose of versionReason and ifUpdatedAt, but the remaining ~28 parameters are left to self-explanatory names without semantic explanation.
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 writes Properties fields (squareMeters, rooms, rent, tenant, notes, …), making the action explicit. It also distinguishes itself from siblings like get_unit (read) and restore_unit (undo) by referencing the snapshot mechanism and concurrency handling.
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 concrete usage direction: always pass versionReason, and use ifUpdatedAt from get_unit.updatedAt to avoid clobbering. It also implies when to use this tool (writing properties) and when to use restore_unit (undoing a bad write), though it does not explicitly list exclusions or alternatives beyond restore_unit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool is a read-only 'show' operation and lists the three pieces of information returned. However, it does not explicitly state side-effect-freeness, authentication requirements, or error behavior. This is acceptable but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no fluff. Every word adds value, making it both concise and structured effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter introspection tool, the description adequately covers the main purpose and specifies the three output fields. Without an output schema, it could be more explicit about the return format, but the description is sufficiently complete for the tool's low complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is an empty object. Per guidelines, 0 params baseline is 4. The description does not need to add parameter semantics, and it does not, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Show') and resource ('authenticated Achi Drive user, auth method, and whether the token has file-content access'). This unambiguously distinguishes it from sibling tools that operate on files, folders, teams, or data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use cases (checking current auth context) but provides no explicit when-to-use instructions or mention of alternatives. There is no direct guidance on when to prefer this tool over others, though the name and standard convention make the intent 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?
With no annotations provided, the description carries full burden for behavioral disclosure. It reveals side effects ('Also files the unit trail and a settlement'), server-side sanitization ('the server strips them'), and an overwrite risk ('so this letter does not overwrite the other stay'). This is substantial, useful transparency even though auth or rate-limit details are absent.
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 dense but not bloated. It front-loads the primary purpose and then adds necessary constraints and side-effect warnings. Every sentence carries operational or safety-relevant guidance, though the paragraph is longer than strictly minimal and could be split for easier parsing.
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 complex tool with 11 parameters and no output schema, the description covers the core behavior, critical constraints, and side effects well. However, it leaves the relationship between the 'createSettlement' parameter and the stated 'files a settlement' behavior unclear, and it does not address return format beyond 'Returns a PDF.' These gaps keep it from a 5.
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 only 18%, so the description must compensate. It does add meaning for 'items' (recoverable line items only), and for occupancyId/periodFrom/periodTo (prevent overwriting when tenants changed). However, it does not explain optional parameters like prepaidEuros, createSettlement, title, greeting, or notes, leaving significant gaps for a tool with 11 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 opens with a specific verb-resource pairing: 'Compile a tenant Nebenkostenabrechnung PDF on the Achi server.' This clearly identifies what the tool produces and distinguishes it from sibling tools like list_nk_settlements or update_nk_settlement, which operate on existing settlements rather than generating a new letter.
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 explicit instructions on when to pass certain parameters: 'If tenants changed mid-year, pass occupancyId + periodFrom + periodTo.' It also provides exclusions ('Do not include Eigentümerkosten leftovers or Quellenangabe') and input constraints ('Pass recoverable line items only'). No alternative tool is named, but the conditions for correct use are 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?
With no annotations provided, the description carries the full burden. It discloses key behaviors: UTF-8 decoding, the 1 MB default cap, and error on non-text-encodable files. This goes beyond the schema by specifying encoding and error behavior, though it does not cover 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?
Two sentences, front-loaded with the primary action. Every word adds value: purpose, encoding, wrapper relationship, cap, and error condition. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with no output schema or annotations, the description covers the essential context: what it reads, encoding, cap, and failure mode. It lacks explicit parameter guidance, but the tool is simple enough that the schema's defaults and field names compensate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters. It mentions 'default 1 MB cap', which indirectly relates to maxBytes, but it never explicitly describes what 'id' refers to or how maxBytes can be customized. The description adds minimal semantic value over the raw 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 tool reads a file as plain text with UTF-8 decoding. It distinguishes itself from sibling read_file by positioning as a convenience wrapper with a default 1 MB cap, and from read_thumbnail by focusing on text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it: as a convenience wrapper around read_file with a default cap. It also indirectly warns against binary usage by stating it errors on non-text-encodable files. However, it does not explicitly name alternative tools for binary or other file types, so it lacks explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the transparency burden. It discloses the mutating actions and partial-update behavior, but does not mention permissions, idempotency, potential side effects, or the response format. The schema separately describes trashed and parentFolderId semantics, which helps but doesn't fully compensate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loading the action list and adding a single instruction on partial updates. No redundant or vague language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 5 parameters and no output schema. The description explains the input operations but omits details about return values, error conditions, and authorization prerequisites. It is sufficient for basic invocation but not fully complete for an agent needing to handle edge cases.
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?
With only 40% schema description coverage, the description compensates by mapping each action to a parameter (rename→name, move→parentFolderId, star/unstar→starred, trash/restore→trashed). It emphasizes that only changed fields need to be sent, giving clear parameter-level guidance beyond the schema's required field list.
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 lists all update operations (rename, move, star/unstar, trash/restore) with a clear resource ('a file'), distinguishing it from sibling tools like update_folder, get_file, and delete_file. The phrase 'Pass only the fields you want to change' clarifies partial-update semantics.
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 states 'in one call' and 'Pass only the fields you want to change', clearly indicating when this tool is appropriate (updating multiple properties of an existing file). It does not explicitly name alternatives or exclusions, but the resource specificity (file vs folder) and sibling context imply usage boundaries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses cursor-based pagination via nextCursor, and clarifies behavior with root/team contexts. This goes beyond the schema and is valuable for a read-only listing 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?
Four succinct, information-dense sentences with no redundancy. Each sentence conveys a distinct operational fact: main purpose, root handling, team handling, and pagination.
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 list tool with 5 optional parameters and no output schema, the description covers purpose, scoping, and pagination. It does not detail the response payload beyond nextCursor, but the essentials are present for an agent to invoke it 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 80%, and the schema already describes all parameters except limit. The description reinforces parentFolderId and teamId semantics but does not add major new meaning beyond what the schema provides, except the pagination tie-in with cursor and nextCursor.
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 action ('List files and folders'), and adds important scoping details (root vs team). This distinguishes it from siblings like get_file or get_folder which fetch specific items, even though no alternative is explicitly named.
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 concrete usage scenarios: omit parentFolderId for root and pass teamId for team drives. However, it does not explicitly state when to use this instead of list_folder_children or search, so it lacks 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?
No annotations are provided, so the description carries the disclosure burden. It adds a valuable behavioral detail: the live row is snapshotted first, making the restore reversible. This goes beyond what the schema shows and helps the agent understand 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?
Two concise sentences front-load the main purpose and add a key behavioral note without any fluff. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with no output schema, the description covers the main operation and a critical behavioral nuance. It does not detail return values or prerequisites, but the provided information is adequate for basic use. Slightly more detail about expected outcomes would make it complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description should compensate. It references 'prior snapshot' which implicitly explains versionId, but it does not explicitly define unitId or versionId, though their names are fairly self-explanatory. The lack of explicit parameter explanation holds this to a mid-range score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (revert), the resource (a Properties unit), and the object (a prior snapshot), making it easy to distinguish from sibling tools like update_unit or list_unit_versions.
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 clear context on when to use the tool (to revert to a prior snapshot), though it does not explicitly mention alternatives or situations to avoid. This is sufficient given the tool's specific role among siblings.
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 behavioral disclosure burden. It clearly discloses that content is not returned, which is a key behavioral trait. It does not mention permission requirements or error behavior, but for a simple metadata lookup this is a transparent and useful disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with two clauses, front-loading the core action and then providing a critical exclusion plus alternative. No wasted words, highly scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter, no output schema), so the description's information about metadata fields and the explicit non-content behavior is adequate for an agent to select and invoke the tool. It lacks details about return format or errors, but these are not essential given the tool's simplicity and the presence of a sibling 'read_file' for content.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explicitly explain the 'id' parameter. However, the phrase 'a single file' implies that 'id' identifies a file. Since there is only one required parameter and the schema already provides type/format, the description adds a modest amount of meaning but does not fully compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves metadata for a single file, naming example fields (name, mimeType, sizeBytes) and explicitly distinguishes itself from content retrieval by naming the alternative 'read_file'. This is specific and differentiates from sibling tools.
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 'Does NOT return content' and directs the user to 'use read_file for that', providing a clear when-not and alternative. This meets the criteria for explicit usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden and does well: discloses size caps (1 MB/5 MB), byte-range semantics, and return-type mapping by MIME type. It does not cover auth or error behavior, but these are less critical for this read operation.
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?
Four tightly written sentences, front-loaded with the core purpose. Every sentence adds useful information (caps, ranges, return types) without repeating schema details.
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 no output schema and moderate complexity, the description covers purpose, limits, ranged reads, and return types. It omits error behavior and what happens when no range is given for a file over the absolute cap, but it is largely complete for a file download 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?
Schema covers 3 of 4 parameters (75%), and the description adds meaningful semantics: explains the cap values, clarifies rangeStart/rangeEnd for large files, and notes maxBytes works with rangeStart. This goes beyond the schema's raw metadata.
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?
Clear, specific verb+resource: 'Download a file and return its content inline.' The description further distinguishes from siblings like read_file_text and read_thumbnail by specifying mime-type-dependent return behavior (text, image, embedded resource).
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 concrete usage context: default/absolute caps and rangeStart/rangeEnd for large files. It implies when to use range parameters but does not explicitly name alternatives or exclusion conditions, so it misses the top tier.
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?
The description discloses the tool's read-only nature through the verb 'List' and specifies the returned data (teams and roles). It lacks explicit mention of authentication or rate limits, but these are not critical for a simple list operation, and no annotations exist to contradict.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action, and no unnecessary words. The usage instruction 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?
For a zero-parameter list tool with no output schema, the description covers the essential: what is listed (teams and roles) and how to use the results. It is complete for its simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, so the description doesn't need to explain any. It actually provides additional context about how the output feeds into the `teamId` parameter of other 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 tool lists all teams the user belongs to, including roles. It distinguishes from siblings like whoami or list_files by targeting the 'teams' resource specifically.
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 instructs to use the returned team IDs as the `teamId` argument for other tools, providing a clear when-to-use directive for team-scoped operations. It doesn't explicitly name alternatives, but the context is unambiguous.
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 the full burden and does so excellently. It discloses recursive behavior in both modes, specifies that permanent delete wipes contents from R2 + DB, and explicitly warns that permanent deletion is irreversible—key behavioral traits for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main action, and every phrase adds necessary information. It efficiently conveys recursion, the two modes, the system impact (R2 + DB), and irreversibility without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a delete tool with two parameters and no output schema, the description covers the essential behavior (modes, recursion, destruction, irreversibility). Minor gaps include not mentioning permissions, error handling, or trash retention duration, but these are not critical for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no descriptions (0% coverage), so the description must compensate. It implicitly explains the 'permanent' parameter by linking it to trash vs. permanent deletion, and 'id' is self-explanatory as the folder identifier. It could have mapped parameters more explicitly, but it adds meaningful 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's dual function: moving a folder to trash or permanently deleting it. It specifically identifies the resource as a folder and emphasizes recursion, distinguishing it from file deletion tools like delete_file.
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 clear context for both modes (trash vs. permanent) and warns about irreversibility, which informs when to use each. However, it does not explicitly mention alternatives like delete_file or state when not to use this tool, so it falls just short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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:

[![drive-mcp MCP server](https://glama.ai/mcp/servers/EBIElimited/drive-mcp/badges/card.svg)](https://glama.ai/mcp/servers/EBIElimited/drive-mcp)

Score Badge

Copy to your README.md:

[![drive-mcp MCP server](https://glama.ai/mcp/servers/EBIElimited/drive-mcp/badges/score.svg)](https://glama.ai/mcp/servers/EBIElimited/drive-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/EBIElimited/drive-mcp'

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