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 only states the primary action of notifying senders; it does not disclose whether messages are marked as read, any irreversible effects, or prerequisites beyond reading via agent_inbox. This is insufficient for a tool that has 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence, front-loaded with the action ('Tells the senders') and no unnecessary wording. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless tool with no output schema, the description covers the core functionality and references the related agent_inbox. It could add a note about when exactly to use it, but overall it is sufficiently complete for its simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so schema coverage is vacuously 100%. The description does not need to explain parameter semantics, and the baseline for 0-param tools is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Tells') and clearly identifies the resource ('senders' regarding 'messages agent_inbox gave you'). It effectively distinguishes this tool from messaging tools like agent_send by focusing on acknowledgment rather than sending new messages.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies the context: use this after reading messages via agent_inbox to confirm receipt. It provides a clear usage context without explicit exclusions, but it does not name alternatives 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.

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 transparently explains the action (announcing yourself) and its target (the mesh), including the specific data shared. It does not mention reversibility or side effects, but for a simple check-in, the core behavior is well disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that front-loads the purpose ('Announces YOU') and provides necessary detail without any filler. Every word adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and no output schema, the description is complete. It explains the tool's purpose, the target (mesh), and the content of the announcement. The simple nature of the tool means nothing else is required.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the baseline is 4. The description adds context about what the announcement includes (role, repo, capabilities), which is sufficient. No parameter-specific details are needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function with a specific verb ('Announces') and resource ('to the mesh'), and enumerates the content of the announcement (your role, repo, capabilities). This clearly distinguishes it from sibling tools like agent_ack or agent_send.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use the tool (when you need to announce your agent session to the mesh), but it does not explicitly state when to use it vs alternatives or mention any exclusions. No conflicting alternative is mentioned, so usage is inferred rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses a prerequisite (check in first) and a time window (since last poll), but does not specify side effects such as whether messages are marked as read, whether polling state is reset, or if a separate acknowledgment (agent_ack) is needed. This is a notable gap for a tool that depends on polling state.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is front-loaded with the verb 'Reads', contains no filler, and conveys the essential information efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only tool, the description is mostly complete, providing the purpose and a prerequisite. However, it omits details about what happens to the messages after reading (e.g., consumption, acknowledgment) and does not describe the output format, which may be important for a messaging tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline is 4. The description adds no parameter-specific detail, but none is needed since the schema is empty and fully covers the parameter space.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (Reads), the resource (messages other agents sent to this machine), and the scope (since your last poll). It effectively distinguishes from sibling tools like agent_send, agent_checkin, and agent_ack, which handle different aspects of agent messaging.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly instructs to check in first with agent_checkin and clarifies that messages are those received since the last poll. This gives clear context for when to use the tool, though it does not mention exclusions or alternative tools by name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden for behavioral disclosure. It does reveal that the current machine becomes the first member, but omits any consequences, side effects, prerequisites, idempotency, or failure behavior. This is minimal disclosure for a state-creating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence with zero filler. Clearly states the action, the resource, and the key distinctive detail about the current machine, making every word count.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-output-schema tool, the description covers the essential purpose and the unique 'first member' aspect. However, it doesn't mention follow-up actions like inviting other members, which would be helpful given the sibling mesh tools, but the simplicity of the tool keeps the gap modest.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema is empty, so the baseline for parameter semantics is 4 per rubric. The description adds no parameter meaning because there are none, but it correctly implies no inputs are needed for the operation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses a specific verb ('Starts') and clearly identifies the resource ('agent mesh') while adding the unique scope 'with THIS machine as its first member.' This distinguishes it clearly from sibling mesh tools like join/invite/revoke by indicating it is the genesis operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'new agent mesh' and 'first member' implicitly convey that this is for creating a fresh mesh rather than joining an existing one. However, it does not explicitly state alternatives or exclusions, such as 'use agent_mesh_join if you already have an invitation.' The guidance is clear context but lacks direct comparison.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden for behavioral disclosure. It adds valuable details: single-use and 15-minute validity. Yet it omits other aspects like permissions required, whether existing invites are invalidated, or what the response contains. The absence of these details leaves the agent without a complete safety/behavioral profile.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, front-loaded with the verb and core resource. It is efficient and easy to parse. However, the sentence ends abruptly with 'ag...', suggesting truncation, which slightly undermines the structural completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no output schema, the description covers the essential purpose and key constraints (single-use, 15-minute validity). Still, it does not explain how this fits into the broader mesh flow (e.g., that agent_mesh_join consumes the code), and the truncation leaves the context incomplete. A fully articulated alternative reference would make it more complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, which per rubric is a baseline 4. The description appropriately says nothing about parameters because none exist. No additional semantic meaning is needed beyond what the empty schema already conveys.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a 'single-use pairing code' with a specific intent to be redeemed by another machine. This is distinct from sibling tools like agent_mesh_join (which presumably redeems) and agent_mesh_revoke (which revokes). The verb 'Creates' and resource 'pairing code' 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.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'another of the user's machines can redeem' implies the use case of pairing a new device, and the 15-minute validity hints at time-sensitive usage. However, there is no explicit 'use this when' or mention of alternatives (e.g., agent_mesh_join for redemption), and the truncated ending 'ag...' suggests incomplete guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 indicates a state-changing action ('enrolls') but does not specify what changes occur, whether the pairing code is consumed, if the machine needs to be restarted, or what happens if already enrolled. Minimal 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that efficiently conveys the core action. However, the text is visibly truncated (ending mid-word at 'ma...'), which harms completeness and structure. It is concise but incomplete as provided.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no output schema, the description provides the essential purpose and method. But it omits any indication of return values, success/failure behavior, or post-conditions. The truncation also leaves missing context, so it is not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters in the schema, so the baseline is 4. The description adds meaningful conceptual input by mentioning the 'pairing code', which is not represented in the schema but is clearly essential to the operation. This aids agent understanding, though it is not formally defined as a parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Enrolls THIS machine'), the target resource ('into an existing agent mesh'), and the method ('using a pairing code'). It is distinct from sibling tools like agent_mesh_create or agent_mesh_invite because it focuses on joining this machine to an existing mesh rather than creating or inviting.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the use case: the user has a pairing code from another machine and wants to enroll the current machine. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden of disclosing side effects. It mentions immediate removal and consequences (stops appearing in the directory, stops receiving messages), but omits reversibility, permissions, or effects on existing connections. Some transparency is present, but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that efficiently conveys the core action and immediate outcome. No wasted words, and the key information (removal, immediacy, directory removal) appears early.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers immediate effects but fails to specify how the target machine is selected, and the text is truncated. Without parameters or an output schema, the description is incomplete for safe and targeted use. It lacks broader context about the revocation process and prerequisites.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has zero properties, yet the tool clearly requires a target machine. The description says 'another machine' but does not explain how the target is identified, leaving the agent without essential information. With no parameters, the description should clarify how the target is derived, but it does not, making this a significant gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Removes another machine from this mesh') with a specific verb and resource, distinguishing it from sibling mesh tools like create/invite/join/status. The scope and immediate effect are mentioned, 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.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for revoking a machine from the mesh, but provides no explicit guidance on when to use it versus alternatives, nor any exclusions. The context of being a mesh management tool partially compensates, but explicit when-to-use details are missing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 read-only nature by saying 'shows whether', which implies a safe status query. However, it doesn't describe output format (e.g., boolean vs. object) or any network dependencies. The definition of agent mesh is partially helpful but truncated, leaving some behavioral context missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence and extremely concise. It front-loads the key action and includes a helpful definition of agent mesh. No wasted words, and the structure is appropriate for a simple status tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter status tool with no output schema, the description mostly suffices, but it is truncated mid-sentence ('whose AI agents...'), which leaves the definition incomplete. It also doesn't state what the return value looks like. Given the full description isn't provided, the tool isn't fully self-contained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the baseline is 4. The description adds context by specifying 'THIS machine', clarifying that the status check is scoped to the local machine rather than any other machine. This is useful semantic context beyond the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: it shows whether the current machine belongs to an agent mesh. This distinguishes it from sibling tools like agent_mesh_create, agent_mesh_join, and agent_mesh_revoke, which modify membership rather than check status. The specific verb 'shows whether' plus the resource 'agent mesh' leaves no ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: use this tool to check if the current machine is part of an agent mesh. It doesn't explicitly state when not to use it or mention alternatives, but the context is clear enough given the sibling tools (e.g., you wouldn't use agent_mesh_create just to check status). No exclusions are stated, but the intended use is obvious.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavior, but it only states the action and target. It does not mention potential side effects, delivery guarantees, prerequisites beyond getting the handle, or behavior on failure. This is a minimal disclosure for a send operation with network implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clearly worded sentence that front-loads the primary verb and object. It includes a useful cross-reference without unnecessary verbiage. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and no output schema, the description covers the essential aspects: what it does, to whom, and where to find the handle. It does not elaborate on the nature of 'coordination messages' or outcomes, but given the tool's simplicity, the description is adequately complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, and the description appropriately avoids parameter details. The pointer to agents_list for obtaining the handle is useful context. Baseline for 0 params is 4, and nothing reduces this.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Sends a coordination message') and the target ('to an agent on ANOTHER of the user's machines'). It also differentiates from siblings by specifying cross-machine communication and references agents_list for obtaining the handle.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides clear context on when to use the tool (sending a coordination message to another machine's agent) and a key prerequisite (get the handle from agents_list). However, it does not explicitly state when not to use it or name alternative tools, so it falls 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of disclosure. It states the read-only nature ('Shows') and provides context about the data returned (delivery and acknowledgment info). However, it does not disclose potential limitations such as message recency, filtering, or scope beyond 'this machine.'

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the verb and resource, followed by clarifying details. No filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (no parameters, no output schema), the description adequately covers what the tool returns: sent messages with delivery and acknowledgment info. It could possibly mention the messaging context (e.g., agent mesh), but the name and sibling tools make this evident.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the description correctly implies that no input is needed. By default, a zero-parameter tool earns a baseline of 4, and there is no additional parameter semantics required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the verb 'Shows' to specify a read operation, and clearly identifies the resource as 'what THIS machine sent,' with additional detail on delivery and acknowledgment status. This distinguishes it from sibling tools like agent_inbox (received) and agent_send (send).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies a use case (checking sent messages and their delivery/ack status) but does not explicitly state when to use this tool instead of alternatives like agent_inbox or agent_ack. No exclusions or alternative tool names are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description bears the full burden of disclosing behavior. It only hints at returning machine associations but does not mention permissions, side effects, return format, or whether agents are filtered by state. The truncated fragment leaves significant behavioral information undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately brief, but it is an incomplete sentence that ends abruptly ('i...'). While it avoids waste, the truncation harms structural completeness and makes it read as an unfinished thought.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no output schema and no annotations, the description is expected to clearly explain what is returned. It starts to say 'which machine each is on' but is cut off, leaving the response format and any additional agent fields undisclosed. For a simple list operation, this is incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there are no parameter semantics to explain. The baseline for 0-parameter tools is 4, and the description's mention of 'ALL the user's machines' adds useful context about the implicit scope, which is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Lists') and a clear resource ('agents currently working across ALL the user's machines in the mesh'), which distinguishes it from siblings like agent_mesh_status or agent_inbox. However, the description is truncated mid-sentence, cutting off the list of details about each agent, so it does not fully specify the output's scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool versus alternatives such as agent_mesh_status or agent_checkin. It implies a monitoring/listing use case but does not state any exclusions or preferred contexts.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It states the mutation, but does not disclose authentication requirements, reversibility, whether completion is idempotent, or what happens if the task is already complete.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. It is appropriately sized for the stated operation, though it sacrifices some useful detail for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a state-changing operation with no annotations and no output schema, the description should clarify what task is affected, prerequisites, or expected outcome. With an empty input schema, the lack of any mention of how the target task is identified leaves a significant contextual gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so there are no parameter semantics to document. The baseline for a 0-parameter tool is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Marks') and resource ('OmniFocus task') with a clear outcome ('as complete'). It is readily distinguishable from siblings such as create_omnifocus_task, list_omnifocus_tasks, and search_omnifocus_tasks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool versus alternatives like todo_complete_task, complete_reminder, or todoist_complete_task. Usage is only implied by the tool name and the action itself.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. Description only states the action without disclosing idempotency, reversibility, or effects if called on an already completed reminder. The lack of parameters raises questions about how the target reminder is identified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence with no wasted words. Front-loads the core action and application.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no parameters, the tool likely requires implicit context (e.g., selected reminder). No output schema is provided. The description is insufficient to understand the tool's full behavior and dependencies.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema coverage is 100%. Per guidelines, baseline for 0 params is 4. Description adds no additional value but is not required to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the action (Marks complete), resource (reminder), and application (Apple Reminders), distinguishing it from siblings like create_reminder or delete_reminder.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use, prerequisites, or alternatives. The agent must infer context; no details on whether a reminder must be selected or if the tool acts on a specific reminder.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 a mutating action ('Adds') and the scope, but it does not disclose whether the operation is reversible, idempotent, permission-gated, or what side effects it may have on existing client configurations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single front-loaded sentence with no filler. It loses a point only because the text appears cut off mid-phrase ('client catalog (...'), leaving the sentence structurally incomplete.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no output schema, the core action and scope are present and understandable. However, with no annotations and no usage guidance, an agent still lacks information about side effects and when this tool should be selected over related configuration or installation tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters and 100% schema coverage is vacuous, so there are no parameter details to supplement. With no inputs, the description appropriately focuses on what the tool configures, matching the 0-parameter baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names the action ('Adds Local MCP'), the target ('config of the MCP-capable AI apps installed on this Mac'), and the source ('LMCP's client catalog'). This is specific enough to distinguish it from single-app connect tools, though it does not explicitly contrast with siblings and the text appears truncated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to use this tool versus alternatives such as lmcp_install_upgrade, recipe_install, or the various connect_* tools. There are no prerequisites, exclusions, or explicit conditions stated, so usage context is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. A connect tool typically initiates an interactive auth flow (opening a browser, requiring the user to log in, possibly returning a login URL), and none of that is disclosed. Only the bare fact of connecting is stated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence with no waste and the action front-loaded. It is efficient but borders on under-specification given the interactive nature of a connect operation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no parameters and no output schema, the description technically covers the minimum. However, for an account-linking tool the agent would benefit from knowing that this is an interactive auth step and what a successful connection yields, which is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the 4 baseline for a parameterless schema applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Connect) and resource (Evernote account), which is unambiguous and clearly the counterpart to the sibling disconnect_evernote. It lacks any explicit sibling differentiation, but none is really needed here.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance, no prerequisites, no mention of what triggers the connection (OAuth flow, browser popup, credentials). The agent is left to infer everything about timing and preconditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full disclosure burden, and it omits the behavior that matters most for a connect tool: that it likely launches an interactive OAuth/browser sign-in, may block on user action, and what state exists on success or failure. Only the add-another/re-auth nuance is disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single compact sentence with the core action front-loaded and the secondary cases tucked into a parenthetical. Nothing is redundant, though the parenthetical slightly muddies the lead statement.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter connect action with no output schema and no annotations, the definition is minimally viable: it says what happens and roughly when. It does not explain the interactive sign-in flow, expected follow-up calls (e.g. list_m365_accounts, set_default_m365_account), or failure modes, leaving real gaps for an agent driving the call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to clarify beyond what the empty schema already shows. Baseline 4 applies; no parameter information is missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource ('Connect a Microsoft 365 account'), which cleanly separates it from disconnect_m365_account, list_m365_accounts and set_default_m365_account by action. It stops short of explicitly naming those siblings or the resulting state, so it is clear but not maximally differentiating.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The parenthetical 'or add another one, or sign one in again' gives useful context for when to call it (first-time link, multi-account, re-authentication), which is more than most connect tools offer. However, it never points to the alternatives such as disconnect_m365_account or list_m365_accounts, nor states prerequisites, so usage is implied rather than prescribed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 fails to mention whether credentials are required, whether a connection state is persisted, whether existing connections are overwritten, or any side effects on other ServiceNow tools.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

While the description is short, it is under-specified rather than appropriately concise. The single sentence does not earn its place because it conveys no useful information beyond the tool name, offering no structural benefit.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is completely inadequate for an agent to understand the tool's purpose, prerequisites, or impact. There are no annotations, output schema, or contextual clues, making it impossible to safely invoke this tool based on the provided information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema is vacuously complete. Per the baseline rule for 0 params, a score of 4 is appropriate even though the description adds no semantic value beyond the name; there is nothing to describe.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Connect ServiceNow.' is a tautology that merely restates the tool name without specifying what connecting actually entails, such as authentication, configuration, or scope. It does not differentiate from related tools like disconnect_servicenow or other ServiceNow operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives, no prerequisites, no context about whether this is a one-time setup or per-session action, and no mention of related tools. The agent receives zero instruction on choosing this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only says 'Connect Todoist.' It does not disclose whether this initiates an OAuth flow, stores credentials, requires user interaction, or has side effects. The agent is left without any awareness of what will happen when invoking this tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at two words, but it is under-specified for a connection tool. It earns its place as a clear subject-verb statement, but lacks critical context about the connection process. It is not verbose, but it is incomplete, so it does not merit a higher score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that there is no annotations, no output schema, and no parameters, the description is the only source of information. 'Connect Todoist' does not explain the connection flow, success/failure conditions, required authentication, or what happens after connection. This is completely inadequate for an agent to safely and correctly invoke the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema is fully covered by virtue of being empty. The baseline for 0-parameter tools is 4, and the description does not need to explain parameters. No additional parameter semantics are required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Connect Todoist' uses a specific verb and resource, making it clear that this tool establishes a connection to Todoist. It distinguishes from siblings like disconnect_todoist and connect_m365_account by naming the target service. However, it does not elaborate on what 'connect' entails, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives such as disconnect_todoist or other connection tools. No context is provided about prerequisites, when a user would need to connect Todoist, or how it relates to the many Todoist task management tools in the sibling list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 states 'Creates an event.' It does not explain whether the tool opens a dialog, saves immediately, requires Mac Calendar to be running, or what default values are used. Behavioral traits are completely opaque.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short (one sentence), which is concise but at the cost of important details. It front-loads the core action but fails to earn its place by omitting critical usage and behavior information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters, no output schema, and missing annotations, the description is severely incomplete. It does not explain what happens when the tool is invoked (e.g., creates a blank event, requires user input, or returns an object) or any return value.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no parameters, so schema coverage is 100% trivially. The description adds no parameter information because none exist. Baseline score 3 is appropriate as the description provides no additional meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool as creating an event in the Mac's Calendar app, distinguishing it from other calendar tools like m365_create_event and update_calendar_event. However, the lack of parameters leaves ambiguity about what kind of event is created (e.g., blank, default, or based on context).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 (e.g., m365_create_event for Outlook). There are no preconditions or exclusions mentioned, leaving the agent without context for appropriate use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does disclose the single most important behavioral trait for a mail tool: it never sends, only writes to the Drafts folder. It says nothing about permissions, whether an existing draft is overwritten, or what a successful call returns, so transparency is partial rather than rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence, front-loaded with the action and destination, ending on the safety-relevant constraint. No filler sentences and nothing redundant with the schema.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-annotation, no-output-schema tool, the description covers the essential risk disclaimer (never sends) but leaves a real gap: it never explains where the email content comes from given the empty input schema, nor what the call returns. Minimum viable rather than complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so per the baseline this scores 4; the empty schema leaves nothing to document. The description does not explain how the draft body is supplied, but with no parameters present there is no schema content to obscure.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Saves), resource (an email) and destination (Mail.app Drafts folder) in one clause, and the trailing negation ('it never sends') explicitly separates it from the many send-capable siblings (send_email, m365_send_email, agent_send). An agent can route between this and the send tools without opening either schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives clear context for use: drafting for human review and manual sending, which is exactly the case that distinguishes it from direct-send tools. It does not name an alternative tool explicitly or state prerequisites, so it falls just short of the top band.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses only the target app and that creation happens in a single account; it says nothing about required permissions, what happens if the folder already exists, whether creation is reversible, or what is returned.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; the verb and target app come first. It is efficiently written, though its brevity is a symptom of under-specification rather than deliberate restraint.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and an input schema that declares no properties at all, the description leaves the agent without the operational details it needs — how the folder is named or targeted, and what happens on failure or duplicate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With zero declared parameters, the baseline is 4. However, the description's phrase 'in one account' implies an account (and presumably a folder name) must be designated, yet neither the schema nor the description explains how that is supplied — a gap the description does not compensate for.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb (creates), resource (mailbox folder), and target system (the Mac's Apple Mail), which implicitly separates it from outlook_create_folder and create_reminder_folder. It stops short of explicitly naming a sibling to differentiate against, so it lands at 4 rather than 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It says what the tool does but never when to use it versus alternatives such as outlook_create_folder or create_reminder_folder, nor any preconditions (account connected, Mail.app running). Usage is only implied by the platform mention.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, and description only says 'creates' without detailing behavioral traits like idempotency, side effects, or permissions. Insufficient transparency for a write operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence is concise, but under-specifies details. Could add value without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Minimal description for a tool with no annotations, no output schema, and many sibling tools. Lacks prerequisites, constraints, or expected behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters in schema; description adds no meaning beyond schema. Baseline for 0 params is 4, but ambiguity about what note is created (content?) lowers to 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states 'Creates a new note in Apple Notes', specifying verb and resource. Distinct from sibling tools like read_note, update_note, list_notes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool instead of alternatives. Does not mention prerequisites or context for creating a note.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds only 'on this Mac', which hints at a local-app dependency, but says nothing about required permissions, whether OmniFocus must be running, which list/project the task lands in, or what a failure looks like for a mutation operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; the verb and target are the first two words. It is efficient, though the brevity shades into under-specification for a write tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and an empty input schema, one sentence is not enough. The agent cannot tell what it must supply, what state the tool changes, or what the return value is.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Parameter count is zero and the schema is an empty object, so the usual baseline would be 4. However, the description offers no indication of how task content is supplied (title, due date, project, tags) for a create operation, leaving a real semantic hole that the description could have acknowledged.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Creates) and resource (a task) scoped to a named product (OmniFocus), so it is distinguishable from generic siblings like create_reminder or todo_create_task. It stops short of explicitly contrasting itself with those siblings, so no differentiation credit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance and no mention of alternatives, despite the sibling list containing several near-identical create tools (todo_create_task, todoist_create_task, create_reminder, create_calendar_event). The agent is left to infer which task backend to target.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'records' implying a write operation, but gives no details on idempotency, authentication requirements, whether emails are sent, or error handling. The return value is mentioned, but broader side effects and constraints 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is efficient, but it is truncated ('per p...') and awkwardly combines two clauses. While not verbose, the incomplete ending and lack of structure prevent it from being more polished.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple (no parameters, no output schema), and the description covers the core action and return value. However, it lacks context about preconditions (e.g., how colleagues are chosen), relationship to list_referral_candidates, and error behavior, leaving it incomplete for a mutation-type tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero properties, so there are no parameters to describe. With no parameters, the baseline is 4, and the description adds context by explaining the tool's behavior (recording invites and returning a unique link), which compensates for the lack of explicit parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool 'records referral invites' and 'returns a unique referral link per person' (assuming 'per p...' means per person). This specifies the action and result, and it is distinguishable from the sibling tool list_referral_candidates which lists candidates rather than recording invites.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not mention when to use this tool versus alternatives such as list_referral_candidates, nor does it give exclusions or prerequisites. It only implies usage after the user has chosen colleagues to invite.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only states the action without disclosing effects like whether it requires the app to be open, permissions, or what the default list is. For a mutation tool, more behavioral context is needed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is efficient and front-loaded. However, it is somewhat under-specified, lacking details that would not add much verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no parameters, no output schema, and no annotations, the description is thin. It doesn't explain what kind of reminder is created (e.g., title, date) or how the user interacts with it, leaving ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there is nothing to describe beyond the tool's action. The description does not repeat schema information. Baseline for 0 params is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'creates' and the resource 'a reminder', and specifies the app 'Reminders.app'. This distinguishes it from sibling tools like 'complete_reminder', 'delete_reminder', etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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, no prerequisites, and no conditions for use. It simply states what it does without context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It does disclose one useful trait – the new list lands in the same account as the default Reminders list with no account selection – but says nothing about naming constraints, duplicate handling, failure modes, or what is returned, and cuts off mid-sentence.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is cut off before completion, so it is not appropriately sized – it is under-specified rather than concise. Nothing is front-loaded beyond the verb-resource pairing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and no parameters, the description should explain expected results or naming behavior. Instead it ends mid-word, leaving the agent without a complete picture of the operation's effect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters and schema coverage is 100%, so the baseline is 4. However, the truncated text ("...list (u...") hints at a qualifier or condition the agent never receives, which is mildly confusing rather than clarifying, pulling this down to 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource ("Creates a new list in Apple Reminders") and gives the list's scope, which distinguishes it from siblings like create_reminder and rename_reminder_folder. However, the sentence is truncated mid-clause ("...default Reminders list (u..."), so the purpose is stated but not fully finished.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to create a list versus using create_reminder, rename_reminder_folder, or get_reminder_folders, and no prerequisites or exclusions are stated. The truncated trailing clause may have contained such guidance, but as delivered none is present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should disclose behavioral traits. It only states it returns data, but does not confirm it is read-only, whether it has side effects, or any other behaviors like caching 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that gets to the point, but it is truncated, making it incomplete. It is concise but not fully formed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no parameters, no output schema, and no annotations, the description should fully explain the tool. It partially explains what it returns but is cut off, missing details about output format, data freshness, or limitations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, so the baseline is 4. The description adds no parameter info, but that is fine since none exist. The description is incomplete but does not mislead.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns a morning briefing combining today's calendar events and reminders. It distinguishes itself from siblings like list_calendar_events and list_reminders by offering a consolidated view. However, the description is truncated, slightly reducing clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. It does not mention when not to use it or any prerequisites. The context of a morning briefing is implied but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. Only states it deletes an event but does not disclose consequences (irreversible, permissions needed, behavior on non-existent ID). Lacks critical behavioral context 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence with no waste, but is too short given the significant gap between description and schema. Overly concise to the point of being incomplete and contradictory.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no parameters and no output schema, the description should provide context on how to obtain the event ID and what the result looks like. It fails to do so, making it incomplete for effective usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has no properties, yet description implies an 'ID' parameter. This is a contradiction: the tool cannot delete by ID without that parameter. The description fails to add meaning beyond the schema and actually misleads.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the verb 'deletes' and resource 'event from Mac's Calendar app', and specifies the method 'by ID'. Distinguishes from sibling tools through the name, but could be more explicit about what 'by ID' means.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives like 'create_calendar_event' or 'update_calendar_event'. No prerequisites (e.g., need to obtain the event ID from a list tool) or exclusions provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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. 'Deletes' conveys a destructive action but does not state whether deletion is permanent, whether an exact title match must be unique, what happens if no matching note is found, or whether confirmation is required. These are significant omissions 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler, front-loading the action and resource before the targeting details. It earns its place fully.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple in schema, but as a destructive operation with no annotations and no output schema, it should clarify permanence, ambiguity handling, and prerequisites. The discrepancy between the description's 'by ID or exact title' and the empty input schema also makes the definition incomplete for an agent trying to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description claims the tool operates 'by ID or exact title,' which is meaningful parameter information. However, the input schema exposes zero properties, so there is no structured way to pass an ID or title. This mismatch leaves the agent uncertain about what arguments to actually provide and their expected formats.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a precise verb ('Deletes'), a specific resource ('a note from Apple Notes'), and the accepted selection modes ('by ID or exact title'). This makes the tool's intent unmistakable and clearly distinguishes it from sibling tools like delete_reminder or gdrive_delete_file.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool should be used when a specific Apple Note needs to be removed, and it even hints at how to target it (ID or exact title). However, it provides no explicit guidance on when not to use it, no mention of listing notes first to obtain an ID, and no comparison to update_note or read_note for alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the tool 'permanently deletes', signaling destructive behavior, but lacks details on permissions, error handling, or return values.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is front-loaded with the key action 'Permanently deletes'. Every word adds value, and there is no redundancy or wasted space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple deletion tool with no parameters and no output schema, the description covers the essential behavior (permanent deletion by ID). It lacks mention of what happens if the ID is invalid, but overall is adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so schema coverage is 100% trivial. According to guidelines, 0 parameters earns a baseline of 4; the description adds no parameter details but none are needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses specific verb 'deletes' and resource 'reminder in Apple Reminders (Reminders.app) by ID', clearly stating the tool's action and scope. It distinguishes from sibling tools like 'complete_reminder' (mark complete) and 'update_reminder' (modify).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for deleting reminders but does not provide explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives like 'complete_reminder' for non-destructive actions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for disclosing side effects. It explicitly warns that the operation deletes the list plus all contained reminders and that it 'cannot be undone,' which is essential for a destructive action. It lacks permission/authentication context, but the irreversibility caveat is strong.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single well-structured sentence that front-loads the action and consequence. Every word contributes; no filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter destructive operation with no output schema, the description is essentially complete: it identifies the target, the cascading effect, and irreversibility. It does not describe the return value, but for a delete operation with no parameterization this is a minor gap given other contextual richness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the schema fully covers all inputs (an empty object). There are no parameters to explain; the description's emphasis on the list-and-contents scope is more relevant than parameter semantics. Baseline of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly identifies the destructive action ('Deletes'), the target resource ('Apple Reminders list'), and the cascading scope ('and all reminders inside it'). Distinguishes itself from sibling 'delete_reminder' which targets a single reminder, and 'rename_reminder_folder' which mutates rather than deletes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description does not explicitly state when to choose this over alternatives such as 'delete_reminder' or 'complete_reminder'. The scoping phrase implies it is for whole-list deletion, but no explicit guidance or exclusion criteria are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, so the description carries the full burden. It discloses that stored tokens are removed, which is important destructive context, but does not state whether the disconnect revokes access, deletes Evernote data, is reversible, or requires re-authentication.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with the action and followed by the key side effect. No redundant or filler language.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple, zero-parameter disconnect tool with no output schema, the description covers the core action and token removal. However, it omits post-condition effects such as whether subsequent Evernote tool calls will fail until reconnection.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so schema coverage is moot. Baseline for a no-parameter tool is 4; the description does not need to explain parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (disconnect) and resource (Evernote account), plus the side effect of removing stored tokens. It distinguishes from connect_evernote by naming the opposite operation, though it does not explicitly call out sibling alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use or when-not-to-use guidance. The action itself implies it should be used when you want to sever Evernote access, but there is no mention of prerequisites, alternatives, or what to do instead if only token refresh is needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It usefully discloses that the stored sign-in is removed (a destructive, credential-level effect), but it does not say whether mail/calendar data is also removed, whether the action is reversible via reconnect, or whether a confirmation is required. The 'ONE' qualifier also hints at an account-scoping rule that is never made explicit despite there being no parameters to select an account.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single tight sentence that front-loads the action and its consequence. No padding or redundant restatement of the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, un-annotated destructive auth tool, the description covers the action and its main effect but leaves the important operational questions unanswered: which account is targeted, whether other data is affected, and whether reconnection is needed to undo it. Adequate as a minimum, but thin for a mutation with no annotation safety net.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema baseline. The implied 'the connected account' targeting is consistent with an empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (disconnect) and resource (Microsoft 365 account) plus the effect ('remove its stored sign-in'), and the emphasis on 'ONE' signals single-account scope. It does not, however, differentiate itself from the nearby sibling set (connect_m365_account, list_m365_accounts, set_default_m365_account, or the other provider *_disconnect tools), so an agent must infer the boundary from the name alone.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use guidance and no mention of alternatives or the related connect/list/set_default siblings. The agent is left to infer that this is the teardown counterpart of connect_m365_account.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears the full burden. It discloses that credentials are removed, which is a destructive side effect, but does not detail prerequisites (e.g., must be connected), post-conditions, or idempotency. Adequate but could add more context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that conveys the essential information with no extraneous words. It is front-loaded and efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple with no inputs or outputs, so the description is minimally complete. However, it could improve by mentioning related side effects like session invalidation or that re-authentication will be required.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema coverage is 100% (empty). The description adds no parameter details, but none are needed. Baseline for 0 params is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Disconnect from ServiceNow') and the side effect ('remove stored credentials'), making it unequivocal what the tool does. This distinguishes it from siblings like connect_servicenow.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when the user wants to sever the ServiceNow connection and clear credentials. It does not explicitly state when not to use or provide alternatives, but the purpose is self-explanatory given the tool's simplicity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It discloses that the tool removes the stored API token, which is a destructive action, and states the disconnect behavior. It could add context about irreversibility or prerequisites but covers the core effect.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence, front-loaded with the action and resource. Every word contributes meaning, with no redundancy or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter disconnect operation with no output schema, the description is sufficiently complete. It explains what happens (disconnect) and the side effect (token removal), covering the essential context an agent needs.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description is not required to explain parameter meaning. The baseline of 4 applies, and the description adds no unnecessary parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action: 'Disconnect Todoist and remove the stored API token.' It uses specific verbs (disconnect, remove) and identifies both the target service and the concrete effect, distinguishing it from connect_todoist and other disconnect tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied by the name and description but not explicitly stated. It does not mention when to use this tool versus alternatives like connect_todoist or how to re-establish the connection. The guidance is minimal but sufficient for a straightforward disconnect operation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does convey the whole observable behavior (pure pass-through of input text, no side effects implied), but it says nothing about output shape, limits on input size, or intended debugging purpose. Adequate but thin for a tool with zero structured behavior hints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence with the behavior front-loaded and zero filler. Nothing to trim.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-output-schema pass-through tool, the description is nearly sufficient. The only shortfall is the absence of any note on typical use (connectivity check) or output format, which is minor.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema declares zero parameters, so per the baseline there is nothing for the description to disambiguate. The description correctly implies no configuration is needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and object ("echoes the input text back"), so an agent knows what happens. However, it is essentially a restatement of the tool name "echo" and adds no distinguishing context against the large sibling set (e.g., debug/utility vs. real messaging tools). Minimum viable clarity, not more.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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, when not to, or what alternatives exist. It gives no hint that this is likely a connectivity/test utility rather than a messaging tool, which matters given siblings like send_message and send_email.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only states the action itself and adds no information about side effects, idempotency, whether an error occurs if already enabled, or what the return value means. This is a minimal behavioral disclosure for an unannotated 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence with no wasted words. It communicates the action, the target, and the precondition efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-output-schema tool, the description covers the essentials: what it does and when to use it. It does not explain return behavior or error cases, but these are less critical for such a simple toggle and no annotations exist to contradict.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With zero parameters and 100% schema description coverage, there are no parameter semantics to clarify. The description correctly implies the tool needs no additional input, matching the baseline of 4 for parameterless tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Turns ... back ON') and resource ('a service in LMCP'), and adds the crucial precondition ('after the user turned it off'). This clearly distinguishes it from state-checking tools like lmcp_state and avoids tautology.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'after the user turned it off' provides clear context for when this tool should be used. It does not name an explicit alternative or exclusion, but for a simple toggle with no sibling enable/disable tools, this is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the entire behavioral burden and delivers nothing beyond the name: no auth/connection prerequisites, no statement of what is required to create a note, and no note about whether existing content is affected. It is essentially a tautology of the tool name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is achieved by omitting necessary information rather than by tight editing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and no declared parameters, the description is far too thin. An agent has no basis for knowing what inputs to supply or what preconditions to satisfy before calling it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema declares zero parameters, so per the rubric this is at baseline 4, but for a creation tool an empty input schema is itself a red flag: the description does not mention title, body, or notebook, which one would expect a create call to require. It adds no semantic value to compensate for the suspiciously empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource (create a note) and the evernote_ prefix ties it to Evernote, so the purpose is discernible. However, it does not differentiate from the generic sibling 'create_note' or the other Evernote note tools (evernote_update_note, evernote_read_note), and gives no indication of what a note consists of.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance is provided. It does not mention that 'connect_evernote' may be a prerequisite, nor when to prefer this over the generic 'create_note' sibling. The agent must infer everything from the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full disclosure burden, and it says nothing beyond the bare action. It does not mention whether an Evernote connection is required (a connect_evernote sibling exists), whether results are paginated, or what a notebook entry contains.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler. Nothing could be removed without losing meaning, and it is appropriately sized for a trivial list operation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-parameter, no-output-schema list tool the description is close to adequate, but it omits the prerequisite that an Evernote account must be connected and gives no hint about result shape or limits, which would help an agent call it successfully.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, which is the baseline-4 case; there is no parameter semantics to document. The description correctly implies an unfiltered, account-wide listing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a clear verb ('List') and resource ('Evernote notebooks'), so the agent knows exactly what the tool returns. It does not differentiate itself from sibling listers like list_notes or notion_list_databases, but the resource is specific enough to distinguish it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by the name and description; there is no statement of when to reach for this versus search_evernote or list_notes. For a zero-argument listing tool the intent is fairly self-evident, but no explicit context or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must carry full behavioral burden. It only states a read action and does not mention authentication/connection requirements, rate limits, error handling, or whether note must exist. Adds no safety or operational context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single front-loaded sentence with no filler. Directly states action and identifier.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, no annotations, empty input schema, and description omits essential context: connection/auth prerequisites, return format, and how the GUID is supplied. Incomplete for a read tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has zero parameters, yet description says 'by its GUID', implying a required GUID input that doesn't exist in the schema. This mismatch makes the parameter semantics misleading; the 0-param baseline of 4 is undercut by the incorrect reference.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb 'Read' and resource 'Evernote note' with scope 'full content' and identifier 'GUID'; distinguishes from siblings like evernote_create_note and evernote_update_note.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use or alternatives. It implies a GUID is needed, but no mention of search_evernote, evernote_list_notebooks, or evernote_update_note. Lacks exclusion guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral disclosure burden. It states that the note is updated, but it does not describe required permissions, whether changes are destructive or reversible, how the target note is identified, or what side effects occur.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single front-loaded sentence with no filler. It states the essential operation and fields without unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and an empty input schema, the description is too thin. It omits how to identify the target note, what parameters are required, and what the update operation does beyond the basic purpose.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, which gives a baseline of 4. The description adds semantic context that the updatable fields are title and content, though it does not specify how the existing note should be selected because the schema provides no parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a clear verb and resource: it updates the title or content of an existing Evernote note. This distinguishes it from evernote_create_note and evernote_read_note, but it does not explicitly differentiate from the sibling update_note.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The word 'existing' implies this is for editing existing notes rather than creating new ones, but there is no explicit guidance on when to choose this tool over alternatives such as evernote_create_note or update_note. Prerequisites and note-selection requirements are also absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a new .xlsx file but does not mention whether it requires special permissions, where the file is saved, whether an existing file can be overwritten, or what the return value is. For a side-effecting tool, this leaves important behavioral traits undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. Every word earns its place: it names the action, the file type, and the core content options. This is ideal conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter creation tool, the description provides the essential purpose and input concept, but it omits key operational details such as the file save location, whether a file path is returned, and how the 'headers and optional data rows' are supplied given the empty schema. The lack of an output schema makes these omissions more significant, resulting in a minimum-viable but not fully complete description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so per the rubric the baseline is 4. The description adds some useful context by mentioning 'headers and optional data rows', giving the agent an idea of what the tool can accommodate, even though no parameters are defined in the schema. It does not need to explain parameter syntax since there are no parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('creates') and a specific resource ('Excel spreadsheet (.xlsx file)'), and it differentiates from sibling tools like excel_read and excel_write_cell by clearly indicating this is for making a new file. It also specifies the content ('headers and optional data rows'), which is precise and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool should be used when creating a new Excel file, which is enough to distinguish from read/write operations, but it does not explicitly state when to prefer this tool over alternatives or mention any exclusions. The usage context is only implied by the verb 'creates'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states 'Reads data' with no mention of return format, read-only guarantees, error handling, or size limits. It leaves all behavioral traits unexplained.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler. Every word adds meaning, and it is appropriately concise for the tool's simple purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description should clarify what 'reads data' returns (e.g., rows, cells, or raw values) and whether it operates on a currently open file. The description is too sparse to fully inform an agent about invocation expectations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, and the baseline for no parameters is 4. The description does not need to explain parameter semantics because there are none, though it could mention how the target file is selected (e.g., current context) to add value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Reads') and resource ('Excel spreadsheet (.xlsx file)'), clearly distinguishing this from sibling tools like excel_create and excel_write_cell. It immediately identifies the tool's primary function and file format.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. While the name suggests reading rather than writing, there is no explicit contextual cue or exclusion (e.g., 'use excel_write_cell to modify'). The description offers no usage scenario.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. The description indicates a write operation but discloses no behavioral traits such as file creation, overwrite behavior, or error handling. The lack of parameters also hides how inputs are resolved.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short, but it is underspecified to the point of being unhelpful. Conciseness is wasted when critical information about parameters is absent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that the tool requires specifying a file, cell, and value to write, and there is no output schema, the description is completely inadequate. It provides no information on how to invoke the tool or what to expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, yet the description implies parameters are needed (file, cell, value). The description adds no meaning beyond the schema and fails to explain how the tool receives inputs. Schema coverage is 100% but irrelevant because parameters are missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states 'writes a value to a specific cell in an Excel file,' which is clear in verb and resource. However, the input schema has zero parameters, contradicting the implied need to specify file, cell, and value. This mismatch undermines clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 siblings like excel_create or excel_read. No context, prerequisites, or alternative suggestions provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the bare operation. It does not say whether the listing is recursive, whether hidden/system files are included, whether the directory is the cwd or requires context, or whether there is pagination or a result cap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler. It is efficient, though the brevity comes at the cost of the transparency noted above rather than being a strength in isolation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and no parameters, the description is the only source of behavioral information, and it says only one sentence. For a filesystem-enumeration tool the agent still needs to know scope, recursion, and result shape, none of which appear here.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema defines zero parameters, so there is nothing for the description to compensate for; baseline is 4. The one open question, which directory is listed, is a schema-level concern rather than a description gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Lists files and folders in a directory'), so the operation is unambiguous. However, it gives no signal distinguishing it from near-identical siblings such as file_list, finder_list, gdrive_list_files, or explorer_search, which an agent would have to disambiguate on its own.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no prerequisites, and no named alternative. With explorer_search and numerous other list/search siblings present, the agent gets no help deciding when directory enumeration is the right call.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full behavioral burden. It discloses that the search is recursive, which is useful, but omits critical traits such as search root, result format, case sensitivity, or whether it searches local files or a specific service. For a zero-annotation tool, 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple tool, though the extreme brevity leaves important context unaddressed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a search tool with no parameters, no output schema, and no annotations, the description is under-specified. It does not explain what the search returns, where it starts searching, or how results are structured, leaving the agent with insufficient information to invoke it confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there are no parameter semantics to explain. The baseline score of 4 is appropriate because the description cannot add meaning beyond an empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('Searches for files') and adds a key scope qualifier ('by name recursively'). However, it does not distinguish this tool from several siblings like file_search, finder_search, or gdrive_search_files, leaving the agent to infer when to use it over those alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers no guidance on when to use this tool versus alternatives like explorer_list or file_search. There is no context about prerequisites, scope limitations, or scenarios that select this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does not specify whether the listing is recursive, includes hidden files, or which directory is listed (current working directory vs. a fixed path). The read-only nature is implied by the verb but not explicitly stated.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. Every word contributes to stating the tool's core function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple zero-parameter tool, the description covers the main purpose, but it lacks behavioral specifics and usage differentiation from sibling file-related tools. It is minimally adequate but leaves room for ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters and the schema is empty, so the description does not need to add parameter-level detail. The baseline for 0-parameter tools is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Lists') and resource ('files and folders') with clear scope ('in a local directory'). It distinguishes from remote listing tools like gdrive_list_files and from search tools like file_search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to use this tool versus alternatives such as finder_list or file_search. The description implies usage but does not state exclusions or preferred contexts.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and states a non-destructive read operation with a specific scope (local, plain text, absolute path). It does not cover error handling, encoding, or size limits, but for a simple read operation, this is a minimal but adequate disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that immediately states the action and target resource. It is efficient, though slightly truncated, but the visible content has no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description conveys the essential purpose and identifies the target file type and location, which is sufficient for selecting the tool among siblings. However, it does not explicitly state the return value, and the absolute path requirement is not reflected in the schema, leaving invocation details incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has no parameters, yet the description specifies an absolute path requirement, which is essential information for invocation. This adds meaning beyond the empty schema, though it highlights a mismatch between the description and schema that the agent must resolve.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Reads'), resource ('plain text file'), and scope ('local filesystem by its absolute path'), and explicitly labels it as the 'primary, default tool' for reading, which differentiates it from siblings like pdf_read or word_read. Even though truncated, the core purpose is unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'primary, default tool for read...' gives clear guidance that this tool should be the first choice for file reading. It does not explicitly mention when not to use it or name alternatives, but the 'plain text' and 'local filesystem' qualifiers implicitly exclude non-text and remote file tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses matching behavior (case-insensitive, partial) and that it starts from a root directory, but it doesn't explain how the root directory is determined given the input schema has zero parameters, nor what the return format is. With no annotations, this ambiguity 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that front-loads the core purpose and key matching behavior. Every word earns its place with no unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema or annotations, the description should clarify return values and operational context (e.g., scope of 'root directory'). It provides only basic search semantics, leaving significant ambiguity for a tool with no parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no parameters, so the baseline is 4. The description adds the concept of a 'root directory' which is not a parameter, but there is no parameter information to clarify further.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches for files and folders by name, with case-insensitive and partial matching details. It identifies a specific verb and resource, though it doesn't explicitly distinguish from sibling tools like finder_search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 file_list or finder_search. No prerequisites or context for invocation are mentioned, leaving the agent without sufficient direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses key behavioral modes (create, overwrite, append), which gives some transparency about side effects (e.g., overwriting destroys previous content). However, with no annotations, it does not mention permissions, prerequisites (like required directories), return behavior, or error handling. It is minimal but provides a basic sense of what happens.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise, front-loaded sentence. It conveys the core action ('Writes text to a local file') and the three modes in a compact, readable format. Every word earns its place with no wasted content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is presented with an empty schema, no annotations, and no output schema, so the description must carry all context. It explains the basic operation and modes but fails to provide any information on how to specify the file path or content, or what the tool expects as inputs. An agent would struggle to invoke this tool correctly based solely on this description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema is empty (0 properties), which gives a baseline of 4 per the rubric. The description does not add parameter names or types, but it does imply the conceptual inputs (text, file destination) and modes. Since there are no parameters to document, the description is not penalized for missing details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool writes text to a local file with explicit modes (create, overwrite, append). It uses a specific verb and resource ('Writes text to a local file') and distinguishes itself from siblings like file_read or file_list by indicating it performs writes, not reads or listings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It does not mention contexts such as needing to create a new file, update an existing one, or append data, nor does it reference sibling tools like file_read or gdrive_write_file. There is no when-to-use or 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavior disclosure. It does add a meaningful behavioral trait (Spotlight-free) and implies a read-only operation. However, it omits critical details such as how the target directory is determined, whether the listing is recursive, or whether hidden files are included, leaving clear gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that wastes no words. 'Lists files and folders in a directory' immediately conveys the action and resource, while '(Spotlight-free)' adds key differentiation without excess. It is an excellent example of minimal yet effective structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is too sparse to be fully complete. It does not specify which directory is listed, how the directory is chosen (current Finder window, home folder, etc.), or what the return format is. For a tool with no parameters, this ambiguity is a significant gap that could cause incorrect usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema is empty with 100% coverage. Per the baseline for 0-parameter tools, the description doesn't need to explain parameter semantics. The description avoids introducing any parameter-related confusion, so a baseline score of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Lists files and folders in a directory'. The parenthetical '(Spotlight-free)' distinguishes it from the sibling tool 'finder_search' by explicitly signaling that it does not use Spotlight, which helps differentiate from similar file-listing tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance is provided on when to use this tool versus alternatives. The '(Spotlight-free)' hint implies avoiding Spotlight, but there is no direct statement about when to prefer this over finder_search, file_list, or other file-related tools. Sibling context exists but is not leveraged.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the behavioral burden. It usefully discloses the Spotlight/mdfind backend and that path= scopes the search. However, it does not describe return format, indexing limitations, or whether hidden files are included, leaving notable gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The entire description is one front-loaded sentence. It wastes no words, states the core behavior first, and appends the useful scoping detail in a clear secondary clause.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a simple tool, but the description omits how the actual search term is passed, which is essential for invocation. It also lacks any return-value or output-shape information, and the path= parameter is not represented in the input schema, leaving an important invocation gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has zero declared parameters, but the description mentions passing path= to scope the search. This adds meaning beyond the schema, yet it conflicts with the empty property list and does not clarify how the main search query should be supplied.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it searches for files by name on this Mac, with an explicit note that it uses mdfind/Spotlight. It also distinguishes the operation from other file tools by highlighting name-based, system-wide search and optional folder scoping.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear usage context: use it for file-name searches anywhere on the Mac, or scope to a folder with path=. It does not list exclusions or name alternative tools, but the intended use case is apparent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral burden. It discloses that only empty folders can be deleted, which is useful, but it omits whether deletion is permanent, what happens on failure, whether files go to trash, and what sync side effects occur. This is insufficient 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is short but visibly incomplete, ending mid-clause with an em-dash and no continuation. It is under-specified rather than concise, and the missing remainder likely contains essential context about the synced Drive path.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a destructive tool with no annotations and no output schema, the description does not cover return values, failure modes, target identification, or safety caveats. The only edge-case information is the 'empty folder' restriction, which is not enough to let an agent invoke this confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there is nothing for the schema to document. However, for a delete operation, the absence of a target parameter is conspicuous, and the description never explains how the file or folder to delete is identified. The description adds little meaning beyond the tool's name.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Deletes') and identifies a clear resource ('a file or an empty folder') and scope ('synced Google Drive folder'). This distinguishes it from OneDrive or local delete tools by domain, though it doesn't explicitly name what it is not.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool over alternatives, no mention of prerequisites, and no exclusion criteria beyond the 'empty folder' restriction. The truncation also cuts off the contextual clause, leaving the intended usage implied rather than stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden and does disclose useful behavior: the folder's tools stop reading it and the change is reversible ('until the user turns it back on'). It does not state whether credentials are dropped, whether other folders are affected, or whether re-enabling requires re-auth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The intent is front-loaded and the sentence is short, but the text is visibly truncated mid-word ('turns it back on i...'), leaving the definition structurally incomplete rather than genuinely concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no annotations and no output schema, the description covers the core effect and its reversibility. The truncated ending, and the absence of any mention of prerequisites or the complementary re-enable tool, leave it short of complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so there is no parameter semantics to document; baseline 4 applies. The description correctly implies the target folder is implicit/selected elsewhere rather than passed as an argument.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource ('Turns one Google Drive folder off') and names the effect clearly, distinguishing it from a general account disconnect by scoping it to a single folder. However, the text is truncated mid-sentence, so the full scope of what 'off' means is left incomplete.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use, when-not-to-use, or named alternative. The sibling gdrive_set_scope likely handles the inverse (turning a folder back on), but the description never mentions it, so the agent must infer the pairing itself.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 that the tool returns metadata (size, dates, type) and mentions 'synced Google Drive,' which hints at scope. However, it does not specify authentication requirements, rate limits, or whether the operation is read-only. This is adequate for a simple metadata fetch but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence of 12 words, front-loaded with the key purpose ('Metadata for a file/folder'). No wasted words; every part is essential.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is brief but critically omits how the tool identifies which file or folder to retrieve metadata for. With zero parameters and no explanation of implicit context (e.g., a currently selected file), an agent cannot reliably invoke this tool. An output schema is absent, but the return values are partially listed. Significant completeness gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so schema description coverage is effectively 100%. The description adds no parameter information, but since there are no parameters, a baseline of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific noun and verb: 'Metadata for a file/folder' clearly indicates it retrieves metadata. It distinguishes from sibling tools like gdrive_read_file (which reads content) and gdrive_list_files (which lists files) by focusing on size, dates, and type.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implicitly states it's for metadata retrieval, but lacks explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, but the context is clear enough for an agent to infer basic usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fails to disclose key behaviors: it does not state that it is read-only, what happens if Drive is not synced, whether it returns full metadata or just names, or if pagination exists. The scope (locally-synced folder) is vague.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence, front-loaded with the verb 'Lists'. Every word adds value, no superfluous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no parameters or output schema, the description is minimally viable but lacks details on return value format, file/folder information included, and prerequisites like Google Drive sync setup. It is adequate for a simple list operation but not comprehensive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters; the description implicitly confirms it takes no arguments by stating it lists a fixed path. This is clear enough, though it could specifically say 'No parameters required'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists files and folders in Google Drive, specifically the locally-synced folder. It distinguishes from siblings like gdrive_search_files (search) and onedrive_list_files (different service), but could be more explicit that it only lists the root of the synced folder.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like gdrive_search_files or finder_list. It does not mention prerequisites (e.g., Google Drive must be synced) or scenarios where this tool is preferred.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden but only says 'Reads a text file', implying a safe read operation. It does not disclose what it returns, error handling, size limits, or whether the file must be locally synced. Critical behavioral details are missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no redundancy. It efficiently conveys the tool's purpose without extraneous details. Ideal conciseness for a simple tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite low complexity, the tool has zero parameters yet claims to read a file. The description fails to explain how the file is identified, making the tool effectively unusable. It also omits return value and error conditions. Incomplete for practical use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no parameters, so description cannot add parameter meaning beyond that. Baseline for 0 params is 4. The description adds context about file types, which is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Reads' and the resource 'text file from the synced Google Drive folder', lists supported extensions, and implicitly distinguishes from sibling tools like gdrive_file_info (metadata) and gdrive_write_file (write). It is specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 (e.g., gdrive_file_info for metadata, fs_read for local files). The description does not mention prerequisites, when-not-to-use, or explicit context for invoking it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It hints at local scope ('synced on this Mac') but does not explicitly state that the operation is read-only or non-destructive. No side effects or authorization needs are disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single concise sentence that front-loads the action and scope. No redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is sufficiently complete for a simple list tool with no output schema, but it could be improved by specifying the kind of information returned (e.g., folder names and IDs). Without an output schema, the agent may need to infer return format from the description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, and the schema covers 100% of expected input. The description adds no further parameter meaning, but none is needed. Baseline 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Lists' and specific resource 'Google Drive folders synced on this Mac'. It also enumerates the scope ('My Drive, Shared drives, per-account mounts'), effectively distinguishing it from sibling tools like gdrive_list_files which list files, not folders.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 (e.g., gdrive_list_files, gdrive_search_files). There is no mention of use cases or explicit conditions for invocation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It mentions recursion and name-based search but fails to disclose output format, case sensitivity, blocking behavior, or prerequisites (e.g., sync status). This is insufficient for an unannotated tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no wasted words, front-loading the key action and scope. It is highly concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description is insufficient. It omits return format, result details, and operational context (e.g., whether it searches only filenames or content). The tool's behavior is underspecified.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema coverage is 100%. The description need not explain missing parameters, and it accurately reflects the tool's no-parameter nature.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (searches), resource (synced Google Drive folder), and method (by name, recursive). However, it does not explicitly differentiate from sibling tools like gdrive_list_files or fs_search, leaving the agent to infer distinctions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. No 'when to use' or 'when not to use' information is provided, and no alternatives are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does disclose that this mutates the 'active' root and that it matters in a multi-account setup, but it omits whether the change is persistent, whether the account selection is interactive, and any auth/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.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with the action front-loaded and the qualifying condition appended. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter state-setting tool with no output schema, the description is minimally adequate: it says what is set and when it applies. It does not explain how the root is chosen among synced accounts or what the resulting effect on gdrive_list_files / gdrive_read_file will be.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so parameter semantics baseline is 4. The description correctly implies the selection is made out-of-band (via synced accounts) rather than through arguments, matching the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: 'Sets the active Google Drive root directory.' An agent knows this changes state rather than reading it. It does not distinguish itself from the sibling gdrive_root or onedrive_set_scope, which is the only gap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The parenthetical '(when multiple accounts are synced)' implies the condition under which this tool is relevant, but there is no explicit when-to-use/when-not guidance and no pointer to alternatives (e.g. gdrive_root) for inspecting the current scope.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description states it overwrites and uploads automatically, which discloses key behavior. However, it does not mention whether it creates new files, requires specific permissions, or has rate limits. Incomplete but acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single, focused sentence that gets to the point quickly. Truncated ending reduces conciseness slightly, but no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Without output schema or annotations, the description should provide more context about file naming, content source, and behavior on overwrite. It is truncated and lacks details needed for safe usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema is empty, so description cannot add parameter info. However, the tool likely needs parameters (content, filename) which are missing, indicating a design gap. Description does not compensate for missing schema details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Describes writing/overwriting a text file in the synced Google Drive folder. Clear verb and resource, and distinguishes from read and search siblings. However, description is truncated, slightly reducing clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives like onedrive_write_file, or when not to use (e.g., binary files). No prerequisites or exclusion criteria are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only says 'recent' without defining recency. It does not mention side effects, permissions, or other behavioral details. For a tool with no annotation coverage, the description should provide more context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, direct, front-loaded with verb and resource. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, and description does not explain return format or structure. The term 'recent' is vague. For a simple tool, more info about the output would aid the agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, so the input schema fully covers semantics. Per guidelines, 0 parameters baseline is 4, and the description adds no further param info.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool returns recent LMCP tool call history from the local audit log, with a specific verb and resource. It is distinct from siblings, none of which relate to audit logs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. The purpose is implied but no exclusions or alternative tool references are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral burden. 'Returns' implies a read-only operation, and the enumerated contents tell the agent what data comes back, but there is no statement about whether license/configuration data is sensitive or whether any permissions are required.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence that names the verb, the resource, and the three content categories with no filler. Nothing needs trimming or reordering.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read with no output schema and no annotations, the description adequately conveys what the agent will receive. The one meaningful gap is the absence of any routing cue versus the several sibling diagnostic/state tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline for a parameterless tool applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Returns) and resource (the current LMCP configuration) and enumerates what it contains: connected integrations, feature flags, license status. This is clear, but it does not distinguish itself from near-siblings like lmcp_state, lmcp_doctor, or permissions_status, which likely report overlapping configuration/health information.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to call this instead of lmcp_state, lmcp_doctor, lmcp_upgrade_diagnostics, or permissions_status. The agent must infer usage purely from the tool name and the enumerated fields.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Description contradicts the empty input schema by claiming it retrieves contacts 'by name or ID', but no parameters exist to supply those values. This is a serious inconsistency that 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence, but its accuracy is compromised, making it less valuable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Without explicit parameters or output schema, the description fails to explain how the agent should specify the contact or what the response contains, leaving critical gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite a zero-parameter schema (baseline 4), the description asserts parameters that are not defined, causing confusion rather than adding meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves a single contact from the Mac's Contacts app by name or ID, distinguishing it from sibling tools that list all contacts or perform broader searches.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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_contacts' or 'list_contacts', nor are any prerequisites or exclusions mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses that it returns the local machine's current datetime, including timezone and UTC offset. This is sufficient for a simple read-only tool; no annotation is available, but the description fills in the key behavioral trait.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, front-loaded with the action and resource, and contains no unnecessary words. It is perfectly concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (no parameters, no output schema), the description provides all necessary context: it returns the current date and time with timezone and UTC offset. Nothing more is required.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With zero parameters and 100% schema coverage, the description adds value by explaining the output will include timezone and UTC offset, beyond what the empty schema conveys.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get'), the resource ('current date and time'), and specifies additional details about timezone and UTC offset. It uniquely identifies the tool among siblings with no ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Though no explicit when-to-use advice is given, the purpose is self-evident: whenever the current date and time with timezone info is needed. No alternative tools exist, so exclusions are unnecessary.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description carries full burden. It does not disclose authentication needs, return format, or any side effects. The phrase 'detailed information' is vague.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence is concise but ends with an ellipsis, suggesting truncation. The important identification method is front-loaded, but the trail-off reduces professionalism.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description lacks completeness. It doesn't specify what fields are returned, authentication requirements, or error conditions. For a tool with no parameters, more behavioral context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has zero parameters, so baseline is 4. The description mentions identification by 'user ID or email', adding context beyond the empty schema, though it's unclear how this maps to actual input.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves detailed info about a specific person from Microsoft 365 directory, using user ID or email as identifier. This distinguishes it from sibling tools like 'get_contact' or 'search_m365_directory'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.