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

No annotations are provided, and the description only indicates a write operation without detailing side effects, persistence, auth requirements, or potential limits. Insufficient for full behavioral clarity.

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 concise and well-structured with a clear purpose sentence and parameter list. No unnecessary content, though could front-load the first sentence more.

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 3-parameter tool with no output schema, the description covers purpose and parameters but lacks return value info and constraints like content length limits. Adequate 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?

Schema description coverage is 0%, but the description explains all three parameters: content as text, source with default, and metadata as key-value pairs. Adds meaning beyond the schema, though metadata format could be more precise.

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 adds a manual memory/note to the personal memory store, and it is distinct from sibling import/sync tools that pull data from external sources.

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 storing manual notes but provides no explicit guidance on when to use over alternatives or when not to use. Minimal direction for an agent.

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 cover behavioral traits. It states a read operation ('Get') with no side effects, adequate but lacks details like rate limits or source constraints.

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?

Description is brief with clear purpose first, followed by parameter list; no unnecessary words, though the 'Args:' label could be omitted for greater 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?

Tool is simple with 3 parameters, all explained; output schema exists so return values are covered. Description is sufficient for the complexity.

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 coverage is 0%, but description explains all three parameters (memory_id required, before/after with defaults), adding meaning beyond type and default values.

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 specific verb 'Get' and resource 'surrounding messages/context for a specific memory', clearly differentiating from siblings like search_memory or add_memory.

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 implies usage when a memory_id is known and contextual messages are needed, but no explicit when-to-use or alternatives are mentioned.

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

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

No annotations exist, so the description carries the full behavioral burden. It does disclose a meaningful trait beyond the schema — that phone numbers and email addresses get mapped to display names — but says nothing about duplicate handling, whether existing contacts are merged or replaced, or what side effects the import has. That is a notable gap for a mutation tool with zero annotation coverage.

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

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

Front-loaded with the one-line purpose, followed by a focused export tip and a short Args block. No redundant restatement of the tool name; the macOS export hint is arguably optional but earns its place as practical input guidance.

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 one-parameter import with no output schema, the description covers purpose, input format, and one behavioral detail (name mapping). It omits what happens to pre-existing contacts and where the data lands, which an agent would want before invoking a write operation.

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 description coverage is 0%, so the schema documents nothing about the single parameter. The description compensates with an Args block clarifying file_path is a path to the .vcf file, adding format meaning beyond the bare 'string' type. It is minimal but fills the coverage 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 ('Import contacts') plus the exact input format (vCard/.vcf), which distinguishes it from import_csv_file and import_json_file in the sibling set. It stops short of explicitly naming those alternatives, so 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?

Provides a concrete 'how to produce the input' tip (macOS Contacts export path), which is genuinely useful context. However, it gives no guidance on when to use this versus sync_contacts or the other import_* tools, nor 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 must carry behavioral disclosure. It mentions auto-detection of delimiter and support for headers, but lacks details on error handling, file size limits, duplicate handling, or side effects. The description provides moderate 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 well-structured with a summary line, followed by additional details and parameter documentation. It is efficient but slightly verbose in listing example sources. Most sentences add 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?

Given 5 parameters (2 required) and no output schema, the description covers parameter usage and general behavior. However, it omits details on return values, success/failure indications, and prerequisites. While adequate, it could be 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 JSON schema has 0% description coverage, but the description's Args section thoroughly explains each parameter, including required ones like content_column and optional like timestamp_column with auto-detection. It adds significant meaning beyond the 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 'Import messages from any CSV file,' specifying the action (import) and resource (messages from CSV). It also lists supported formats and provides examples like LinkedIn exports, differentiating it from sibling import tools for other formats.

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 CSV files and mentions specific sources, but does not explicitly state when to use alternatives (e.g., import_json_file) or provide conditions for not using this tool. Some guidance on exclusion is 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 explains that all messages from all channels and DMs are imported and that both folder and ZIP formats are accepted, but it does not disclose potential side effects like processing time, size limits, or whether the import overwrites existing data.

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—four sentences that get straight to the point. It front-loads the purpose, then provides user guidance, and ends with parameter details. 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?

For a single-parameter tool with no output schema, the description covers the essentials: what it does, how to get the data, and the parameter format. It does not explicitly state the outcome (e.g., that data is added to memory), but sibling names like add_memory provide implicit context.

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 0% description coverage, so the description must compensate. The Args section adds meaning by stating that 'package_path' can be a path to an extracted folder or a ZIP file, clarifying the acceptable formats beyond the schema's minimalist title.

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 'Import' and the resource 'Discord Data Package (GDPR export)', and distinguishes it from sibling tools like import_csv_file or import_messenger by specifying its Discord-specific origin.

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 provides context on how to obtain the data (Discord Settings > Privacy & Safety > Request All of My Data) and notes that both extracted folders and ZIP files are supported. However, it does not explicitly state when to use this tool over alternatives or 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?

No annotations; description does not disclose side effects (e.g., overwriting, idempotency), relying only on 'import' as a vague action.

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?

Two sentences plus an args line, no wasted words, efficiently conveys purpose and argument.

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?

Covers source format, acquisition steps, and parameter description; lacks error handling and output behavior, but adequate for a single-parameter import 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?

With 0% schema coverage, the description adds valuable meaning by specifying the data_path as the extracted folder containing 'your_instagram_activity/', beyond just type.

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 imports Instagram DMs from a GDPR export in JSON format, specifying verb and resource uniquely among siblings.

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 explicit download instructions and argument format, but lacks explicit when-not-to-use or alternative 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 burden. It explains what the tool does and parameter roles, but does not disclose whether import is additive or destructive, what happens on failure, or any file size limits. Core behavior is covered, but side effects and error handling are omitted.

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 brief (four sentences plus list), front-loads the core purpose, and uses a clear structure. Every sentence adds value without repetition or 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?

Given 5 parameters, no output schema, and no annotations, the description covers purpose, format support, and parameter details. It lacks mention of return value or side effects (e.g., whether data is appended or replaced). Considering complexity, it is mostly complete but misses output context.

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 description coverage is 0%, but the description provides full parameter details in an Args section: purpose, required/optional status, and default values. This adds complete meaning beyond the schema, which only lists names and types.

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 imports messages from JSON files, specifies supported formats (arrays, JSON-lines, wrapped objects), and lists example data sources (Google Chat, Hangouts, LinkedIn). It distinguishes from siblings by focusing on generic JSON import rather than platform-specific formats.

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 use for JSON files, especially those from common services, but does not explicitly exclude other formats like CSV (handled by import_csv_file) or state when not to use this tool. It provides context but lacks explicit alternatives or exclusion criteria.

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. It only states that the tool imports messages, but does not disclose side effects (e.g., whether it overwrites existing data, requires authentication, or has rate limits). With no further behavioral context, the description is insufficient.

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

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

The description is brief (3 sentences) and front-loaded with the purpose. The second sentence provides actionable download instructions, and the third defines the parameter. No redundant information, though the parameter definition could be integrated more seamlessly.

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 import tool with one parameter and no output schema, the description covers the essential aspects: what, format, how to obtain data, and expected input. It does not describe the return value, but this is less critical for a straightforward import operation.

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 0% description coverage, but the description adds meaningful context by explaining that 'data_path' should point to the extracted folder containing 'messages/inbox/'. This compensates well for the schema's lack of detail.

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 specifies exactly what the tool does: import Facebook Messenger messages from a GDPR export in JSON format. It distinguishes itself from sibling import tools (e.g., import_instagram, import_discord_package) by naming the source platform and 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?

Provides clear steps for obtaining the required data (Facebook Settings > Download Your Information) and specifies the expected folder structure (messages/inbox/). However, it does not explicitly state when to use this tool over alternatives, though the tool name and context make the context clear.

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 does not disclose behavioral traits such as whether the import is additive, idempotent, or requires specific permissions. The basic action is stated, but deeper behavior is omitted.

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 concise: two sentences plus an Args line. The first sentence front-loads the purpose, and every part is necessary. 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?

Given the tool's simplicity (one parameter, no output schema), the description covers the essentials. However, the lack of behavioral transparency and any usage guidance leaves gaps for an agent to fully understand the tool's implications.

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 0% schema description coverage, the description adds meaning by explaining what 'file_path' is ('Path to the XML backup file'). However, it lacks details like accepted formats, validation rules, or examples, so it only partially compensates.

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 'Import' and the resource 'SMS/MMS messages' from a specific source format (Android SMS Backup & Restore XML). This distinguishes it from sibling import tools for other formats.

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 users have an Android SMS Backup & Restore XML file, but it does not explicitly state when not to use it or mention alternatives among the many sibling import 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states the import action without mentioning side effects (e.g., whether data is appended or replaced), validation of the .txt format, error handling, or required permissions. This leaves critical behavioral gaps.

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

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

The description is short and front-loaded with the core purpose. The Args formatting adds minor verbosity but overall remains 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?

Given the simplicity of the tool (single parameter, no output schema, no annotations), the description covers the essential file path requirement but lacks details on file format expectations, success/failure indications, and any limitations. It is adequate but not comprehensive.

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

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

With 0% schema description coverage, the description adds necessary context by specifying 'absolute or relative path' and 'WhatsApp .txt export file'. However, it does not detail expected formatting, encoding, or size constraints, leaving some ambiguity.

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 (import), resource (WhatsApp chat export .txt file), and destination (into memory). It distinguishes from sibling tools like import_csv_file or import_discord_package by being specific to WhatsApp .txt exports.

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 guidance on the file_path parameter (absolute or relative path) but does not give any when-to-use or when-not-to-use instructions relative to alternative sibling tools like import_csv_file or sync_imessage.

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 basic action without disclosing behavioral traits such as read-only nature, performance implications, or any 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 sentence that immediately conveys the action and result, with 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?

Given no output schema, the description mentions 'message counts' to hint at return value. It is mostly complete for a simple listing tool, though could specify if any filtering or sorting applies.

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 zero parameters, and schema coverage is 100%. The description adds no parameter info, which is acceptable with no parameters, earning a baseline of 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 tool lists all data sources and their message counts, which is a specific verb+resource that distinguishes it from sibling tools that import, sync, or manage memory.

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 viewing available data sources, but provides no explicit guidance on when to use this tool versus alternatives like sync tools or search.

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 cover behavioral traits. It only states the action and output, omitting details on blocking behavior, duration, side effects, or auth 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, front-loaded sentence efficiently conveys the purpose, scope, and output without 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?

For a simple trigger tool with no parameters and no output schema, the description covers the main elements. However, missing usage context relative to siblings slightly reduces completeness.

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% coverage. The description confirms no inputs are needed, adding minimal but sufficient context for a parameterless tool.

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 ('trigger sync'), scope ('all configured sources'), and output ('return new message count'). However, it does not differentiate from the sibling tool 'sync_all', which likely has similar functionality.

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 sync_all or individual sync tools. The description lacks context on prerequisites or suitability.

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 disclose behavioral traits. It mentions 'hybrid keyword + semantic search' and filtering options, but does not state whether the operation is read-only, rate limits, authentication needs, or side effects. The description is adequate but not fully transparent.

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 well-structured with a brief opening line followed by an Args list. It is front-loaded and each line adds value. However, it could be slightly more concise (e.g., removing 'Args:' header for pure conciseness). Still, it is efficient and clear.

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 output schema exists (not shown but indicated), the description does not need to explain return values. It covers all 6 parameters thoroughly, including defaults and filters. For a search tool, it provides sufficient context for an agent to use 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?

Input schema description coverage is 0%, so the description compensates fully. It provides clear, explanatory text for each parameter: 'Natural language search query', 'Maximum number of results to return (default: 10)', filter explanations with examples (e.g., 'whatsapp:printer_conspiracy'), and date formats with examples ('2026-01-01'). This adds significant meaning beyond the 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: 'Search your personal memories using hybrid keyword + semantic search.' It uses a specific verb ('search') and resource ('personal memories'), and distinguishes itself from sibling tools like add_memory and various import/sync 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?

The description implicitly clarifies usage context by contrasting with sibling tools (add, import, sync), but does not explicitly state when to use or avoid this tool. No alternatives are named, but the purpose is clear enough for an AI agent to differentiate.

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 says the tool refreshes memory and re-reads changed files, but it does not disclose side effects, idempotency, permissions, whether existing memory is overwritten or merged, or what happens on partial failure.

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?

Three short sentences, front-loaded with the core action, and no wasted wording. The no-argument constraint is stated directly and reinforces the scope.

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 and no annotations, the description explains the basic scope but omits sibling differentiation and sufficient behavioral detail for a refresh operation. An agent can call it correctly, but cannot confidently choose it over sync_all.

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 sets the baseline at 4. The description appropriately confirms this by stating it takes no arguments and can only refresh what the server owner has already configured.

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 operation: refresh memory from configured sources, run every server connector, and re-read changed import files. It is clear what the tool does, but it does not explicitly distinguish itself from sibling tools like sync_all or the per-source sync_* 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?

It implies usage by saying it refreshes everything already configured and takes no arguments, so it cannot target arbitrary sources. However, it does not state when to use this instead of sync_all or individual sync_* tools, nor does it name any 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 must fully disclose behavior. It mentions syncing each connector but does not discuss potential side effects, error handling, or whether the operation is idempotent.

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 two sentences long, front-loaded with the main purpose, and each sentence adds value without 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 has no input schema and no output schema, the description provides essential context: iterates over configured connectors and returns counts. It could mention behavior on failure or ordering, but is fairly complete for a batch sync command.

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 input schema is empty. The description adds no parameter information, which is acceptable since 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 ('sync every configured connector') and output ('return counts per source'), listing specific connector types, which differentiates it from individual sync sibling 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?

The description implies usage when syncing all configured connectors is desired, and the sibling tools provide clear alternatives for individual syncs. However, it does not explicitly state when not to use or any prerequisites.

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 the source, target table, name-mapping behavior, and platform-specific empty-result behavior, but it does not say whether existing contacts are overwritten or merged, whether permissions are required, or how repeated syncs behave.

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, front-loaded with the primary action, and structured into purpose, mapping effect, and platform caveat. Every sentence adds useful information without 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 parameterless sync tool with no output schema and no annotations, the description covers the source, target, mapping effect, and platform behavior. It leaves some mutation semantics unstated, but it is nearly complete for correct invocation.

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 are no parameter semantics to clarify. The schema coverage is listed at 100%, and the description correctly adds no unnecessary parameter detail beyond the tool's 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?

The description names a specific verb (sync), resource (contacts), and source (macOS AddressBook), and states the effect of writing into the contacts table. It is clearly distinguishable from generic sync siblings by its macOS-specific source, though it does not explicitly contrast itself with import_contacts_vcf or other contact-import 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?

The description gives an implied usage context: syncing native macOS AddressBook contacts. It also states a platform constraint (macOS only; empty result elsewhere). However, it never says when to choose this over siblings such as import_contacts_vcf, nor does it describe prerequisites or exclusions beyond the platform 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 must carry full behavioral burden. It only says 'sync' without disclosing traits like read/write nature, rate limits, permissions, or impact on state. Minimal 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 extremely concise (two lines) and front-loaded with purpose. 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?

Given a simple tool with 1 optional param and no output schema, the description covers purpose and parameter usage. However, it omits return value, behavior (does it store or just fetch?), and interaction with the configured channel. Adequate but 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?

With 0% schema description coverage, the description compensates by explaining that channel_id is a Discord channel ID and can default from an env var. This adds meaning beyond the schema's type and default.

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 syncs recent Discord messages from a configured channel, which is a specific verb and resource. However, among many sync siblings (sync_email, sync_slack, etc.), it does not differentiate beyond the platform name.

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 (e.g., sync_all, import_discord_package). The description does not provide prerequisites, when-not-to-use, or exclusion criteria.

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 discloses the per-folder UID checkpoint (indicating incremental sync), required environment variables, and the default folder. It does not hide any 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 divided into a one-sentence summary, a behavioral paragraph, environment variable requirements, and an Args section. Every sentence adds value and there is no 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 simplicity of the tool (2 parameters, no output schema), the description covers all necessary aspects: purpose, behavior (UID checkpoint), prerequisites (env vars), and parameter details. It leaves no 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 provides only type and default for folder and max_emails. The description adds meaningful context: folder options with examples like '[Gmail]/Sent Mail', and max_emails as a cap per sync. This fully compensates for the missing schema descriptions.

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 starts with 'Sync Gmail messages into memory via IMAP.', clearly stating the verb (sync), resource (Gmail messages), and mechanism (IMAP). It distinguishes itself from sibling sync tools (e.g., sync_slack, sync_discord) by targeting email, specifically Gmail.

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 mentions that it fetches emails from a Gmail folder and stores them for search, and explains that it uses a UID checkpoint to avoid re-ingesting. It does not explicitly state when not to use it, but the context is clear for Gmail email syncing.

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 and does so well: it discloses read-only access, platform restriction ('returns an error dict on other platforms without raising'), the Full Disk Access prerequisite, and the IMESSAGE_DB_PATH override. It omits idempotency/incremental behavior and whether existing synced data is replaced, which for a sync tool would matter.

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?

Front-loaded with the core purpose, then platform/prerequisite details, then the argument. Every sentence carries information, though the Full Disk Access sentence is somewhat long and the parenthetical remediation command is more operational than agent-facing.

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 single-optional-param tool with no output schema, the definition covers platform, prerequisites, path override, and filter semantics adequately. The return shape is only hinted at ('error dict'), so an agent has a mild gap on what a successful sync produces, but nothing critical 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?

Schema description coverage is 0%, so the description must compensate, and it does: chat_name is explained as an optional filter matching against chat_identifier (with the '+1234567890' example) or display name. This adds real matching semantics the bare 'Chat Name' property name does not convey.

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+resource ('Sync iMessage/SMS conversations from the local macOS Messages database') and names the exact data source (chat.db). It clearly distinguishes itself from siblings like sync_signal, sync_telegram, and import_sms_backup by anchoring to the local macOS Messages store rather than another provider or an import path.

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 gives clear operational context: macOS-only, read-only, and the Full Disk Access requirement with a concrete remediation command. It does not, however, tell the agent when to prefer this over sync_all or import_sms_backup, so the alternative-selection guidance is 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?

No annotations are provided, so the description carries full burden. It covers authentication but fails to disclose critical behavioral traits such as whether syncing overwrites or appends to existing memory, potential rate limits, or error handling. The term 'sync' is ambiguous regarding 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 well-structured with sections (purpose, API details, environment, Args). Every sentence adds value, though it could be slightly more concise by merging the environment and args sections.

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 authentication and parameter details but lacks information on the sync behavior (e.g., does it merge or replace?), error handling, and rate limits. Given that no output schema exists and the tool imports external data, these gaps reduce completeness.

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 0% schema description coverage, the description thoroughly explains each parameter in the Args section, including defaults and environment variable fallbacks. This adds significant meaning beyond the bare JSON Schema, though it could be more precise about input 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 clearly states the action ('sync'), resource ('Mastodon posts'), and scope ('recent', 'public or hashtag timeline'), making the purpose specific and unambiguous. It distinguishes from sibling tools by explicitly mentioning 'Mastodon', which is unique among the listed sibling 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?

The description provides clear context on authentication requirements (public/hashtag vs home/private) and environment variable alternatives. While it doesn't explicitly say when to use this tool over alternatives (e.g., sync_all), the sibling tools are clearly for different platforms, so usage is implied.

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?

Without annotations, the description carries the burden of behavioral disclosure. It reveals the use of a pagination token to avoid re-ingesting and the need for environment variables. However, it does not mention potential side effects, idempotency, rate limits, or authorization requirements beyond token provision.

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 well-organized with a purpose paragraph and an Args section. It is concise at 8 lines but repeats the environment variable information slightly. The structure is front-loaded with the core action.

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 low complexity (one optional param, no output schema, no annotations), the description covers the main aspects: purpose, parameter, prerequisites (env vars), and internal mechanism (pagination token). It is complete enough for an agent to use, though it omits details like message limits or rate limits.

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 minimal structure (one optional parameter with title only). The description adds critical meaning: the parameter format (example Matrix ID), fallback to environment variable, and default behavior. This fully compensates for the 0% schema description coverage.

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 (sync Matrix room messages) and the resource (messages stored for search). It distinguishes itself from sibling sync tools by naming the platform 'Matrix', but does not explicitly differentiate its behavior or use case from them.

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 mentions required environment variables and optional room_id, but provides no guidance on when to use this tool instead of alternatives like sync_slack or sync_discord. There is no indication of prerequisites or 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?

No annotations are provided, so the description bears full responsibility. It does not disclose whether the operation is read-only or destructive, what happens on duplicate syncs, or if it modifies the source database. It lacks details on authorization needs or error conditions.

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 organized into clear sections: purpose, prerequisites, database paths, environment variables, and args. It is front-loaded with purpose. While slightly verbose on path details, every sentence adds value without 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?

Covers setup requirements and parameter usage, but lacks information on return values, side effects (e.g., data storage location in the study), and what 'sync' entails behaviorally. Given no output schema, the description should clarify outcomes.

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 coverage is 0%, but the description explicitly explains the single parameter 'conversation_id' as an optional filter that accepts 'ID, name, phone number, or profile name'. This adds significant meaning beyond the schema's bare type definition.

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 'Sync Signal Desktop messages from the local encrypted database', specifying the verb (sync), resource (Signal Desktop messages), and unique scope (local encrypted database). It distinguishes from sibling sync tools (e.g., sync_discord, sync_telegram) by naming Signal specifically and providing platform-specific database paths.

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 importing data from other sources. It only lists prerequisites (Signal Desktop, pysqlcipher3) but does not mention scenarios where sync_signal is appropriate or when to use other sync/import 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?

No annotations; description mentions API usage and scopes but omits behavior on errors, rate limits, or whether it's read-only (though implied).

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?

Concise, well-structured with clear lead sentence and Args section; no extraneous 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?

Covers parameter and requirements but lacks description of return value or side effects (only says 'into memory').

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?

Adds complete meaning to the single parameter with type, example, and fallback behavior, compensating for 0% schema coverage.

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 it syncs recent Slack messages into memory, distinguishes from siblings by specifying Slack and using Slack Web API.

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 prerequisites (scopes, env vars) but lacks explicit guidance on when to use vs alternatives (e.g., sync_all) or when not to 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?

Description discloses core behavior: uses getUpdates, syncs since last sync, requires token, and filters by chat_id. However, it lacks details on side effects (e.g., memory updates, deduplication), idempotency, error handling, or rate limits. Without annotations, the description carries the burden but covers only essential mechanics.

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?

Description is structured with a clear purpose line, technical details, and an argument section. It is reasonably concise but could tighten the arg description into fewer sentences. 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?

Given no output schema and no annotations, the description explains the tool's operation and parameter adequately but misses output behavior or return value. It does not mention what the tool returns (e.g., count of synced messages) or error scenarios. Sibling tools might have similar gaps, but for a mutating sync tool, more completeness would help.

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 adds significant meaning beyond the schema: explains chat_id sign convention (positive DM, negative group), default behavior (syncs all chats if omitted), and environment variable fallback (TELEGRAM_CHAT_ID). Schema coverage is 0%, so this full explanation compensates completely.

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 'Sync new Telegram messages received by the bot into memory,' providing a specific verb (sync), resource (Telegram messages), and scope (new messages received by bot). It distinguishes from siblings like sync_discord by explicitly naming Telegram and the bot-specific nature.

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 vs alternatives (e.g., import_telegram, other sync tools). It mentions a prerequisite (TELEGRAM_BOT_TOKEN) but does not specify exclusion criteria or recommend alternatives for different use cases.

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