Metis Public Health

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

With no annotations, description discloses upsert semantics (created_at preserved, definition overwritten) and return value. Adequate for a simple mutating tool; could mention idempotency or side effects but sufficient.

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, front-loaded with core purpose, efficient use of sentences, structured with Args section. 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?

Complete for a two-param tool with output schema: covers purpose, behavior, parameters, return, and sibling relation (get_glossary). No 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?

Adds significant meaning beyond schema: explains term is unique key (reuse overwrites definition) and definition is the text. Schema coverage 0% so description compensates fully.

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 states specific verb 'Add or update' and resource 'glossary term', clearly distinguishing from sibling 'add' tools like add_journal_entry by focusing on glossary terms and mentioning retrieval via get_glossary.

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 context for when to use (maintain consistent definitions across sessions) and mentions alternative retrieval tool (get_glossary). Lacks explicit when-not-to-use or exclusions, but guidance is 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?

Mentions auto-extraction of mood and energy, but does not describe behavioral traits like whether it overwrites existing entries, permissions needed, or side effects. With no annotations, more detail would be warranted.

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?

Extremely concise: two lines of prose plus parameter descriptions. Every sentence adds information without redundancy. Front-loaded with the core 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?

For a simple two-parameter tool with an output schema, the description covers the essential functionality and parameter meaning. Minor omission: does not explain what happens during auto-extraction or error handling.

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?

Provides clear, human-readable explanations for both parameters (content and image_path), which the input schema lacks. This adds significant meaning beyond the schema's property titles.

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 tool stores a journal entry and highlights the key feature of auto-extracting mood and energy. This distinguishes it from sibling tools like add_memory_entry.

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 such as add_memory_entry. The description only states functionality without context for selection.

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 must carry the full burden. It discloses that it inserts into the memory_entries table and optionally writes a markdown file, and describes the return value (confirmation or error). It lacks details on idempotency, concurrent access, or specific error conditions, but covers the main behavioral aspects adequately.

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: a concise purpose statement, usage guidance, a brief internal description, then clearly labeled parameter explanations, and the return value. It is front-loaded with essential information and every sentence earns its place 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 6 parameters (3 required), no schema descriptions, and the presence of an output schema, the description provides comprehensive coverage. It explains all parameters, the underlying database operation, file creation, and the return type. No gaps are evident for an agent to 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 input schema has 0% description coverage, but the description's Args section provides clear, meaningful explanations for each parameter (e.g., summary: 'One-paragraph summary, stored in the DB and shown in search'). This fully compensates for the schema gap and adds value beyond parameter names.

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 adds a memory entry to the memory palace, specifies it's for human-curated notes with title, summary, and topics, and distinguishes it from store_episodic_memory and store_semantic_memory for machine logging or distilled concepts. The purpose is specific and well-differentiated from 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?

Explicitly tells when to use this tool ('human-curated memory palace note') and provides direct alternatives: store_episodic_memory for machine logging, store_semantic_memory for concepts. This gives clear context and helps the agent choose correctly.

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 fully carries the burden. It details the mechanism (appends to user-config.yaml, creates file if absent, updates existing contexts by name), the effect of the active_by_default parameter, and the return value. This is comprehensive 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 somewhat lengthy but well-structured with a clear opening, implementation details, related tools, and parameter definitions. It could be slightly more concise without losing clarity, but it remains focused and effective.

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 presence of an output schema, return values are adequately covered. The description explains the tool's effect on the user config and active contexts. It could mention error handling, but overall it is complete enough for a mutation tool with three 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?

Schema coverage is 0%, but the description adds rich meaning to all three parameters: explains name as a key for updates, description as text, and active_by_default as controlling immediate activation. This far exceeds what the schema alone provides.

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 adds or updates a specialist context to the user profile. It specifies the resource and action, and distinguishes itself from sibling tools like toggle_context and list_contexts by naming 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 explains when to use this tool: to inform Metis about user domains for tailored routing and search. It mentions related tools (toggle_context, list_contexts) but doesn't explicitly define when not to use it. This provides adequate but not exhaustive 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 provided, but the description fully discloses behaviors: it records modification time, sets watch, updates on re-add, and the effect of empty label on re-add. Could mention permissions but overall sufficient.

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?

Well-structured with a brief lead, behavioral explanation, args section, and returns. Information dense but not overly long; every sentence contributes 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 the tool's simplicity (2 params, no annotations, has output schema), the description covers all necessary information: purpose, usage, parameters, behavior, return value, and related tool. Fully adequate for agent 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?

Schema has 0% description coverage, so description adds all parameter meaning: path must be absolute and exist, label optional with default and special re-add behavior. Essential details for correct invocation.

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 tool adds a single file to the tracked-files list and starts watching it. Differentiates from 'connect_project_folder' which registers a whole project, ensuring the agent understands the 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?

Explicitly tells when to use (single file) and when to use an alternative (connect_project_folder for a whole project). Also states prerequisites (file must exist) and behavior on re-add.

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 full behavioral disclosure burden but only says 'Add a topic to track for new publications.' It does not mention side effects (e.g., overwrite existing topic), required permissions, rate limits, or any behavioral constraints. The uniqueness hint in the param description is about parameter validation, not tool behavior.

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

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

The description is very concise: two lines of purpose and two parameter lines. It is front-loaded with the primary action, and every sentence adds value. There is no redundant or tangential 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 the tool's relative simplicity and the existence of an output schema (not shown), the description covers the core add operation. However, it omits context like whether topics persist across sessions, any maximum limits, or connection to the publication tracking system. 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?

The input schema has 0% description coverage, so the description fully compensates by explaining each parameter: 'topic' is uniquely named, 'description' is optional for search criteria. This adds meaningful semantics beyond the schema's bare type definitions.

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 adds a topic to track new publications. It uses a specific verb ('Add') and resource ('topic'), with a clear purpose. The context for new publications distinguishes it from other 'add_' sibling tools like add_glossary_term or add_journal_entry.

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 provide explicit guidance on when to use this tool versus alternatives. It lacks any mention of prerequisites, when not to use it, or comparison to sibling tools that might also manage tracked items.

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, description carries full burden. It states it reads reflexion_log entries, aggregates themes, and returns ordering by busiest agent. It does not disclose modification status (implied read-only), performance implications, or error handling. Sufficient for overview but lacks depth.

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 with a code block for the parameter list. Purpose is front-loaded. Minimal waste, though '(Phase 9b)' may be noise. Overall concise and well-structured.

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 simple parameters and existence of output schema, description is fairly complete. It explains what is returned (themes, ordering). Lacks detail on what 'top recurring' means or number of themes. Adequate for a focused 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 0% description coverage, so description must add value. It explains agent_slug limits scope (leave blank for all agents) and days defaults to 14. This adds meaning beyond schema defaults, but does not specify format or constraints on agent_slug. Adequate for two simple 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?

Description clearly states the tool themes recent reflexions per agent, reading from reflexion_log and returning specific themes. It is specific about verb (theme), resource (reflexions), and scope (per agent). However, it does not explicitly distinguish from sibling 'consolidate_reflexions_tool', so not 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?

Description explains when to pass agent_slug to limit scope (leave blank for all agents), which implies usage context. However, it does not provide explicit when-not-to-use or compare with alternatives like consolidate_reflexions_tool. Guidance is implied but incomplete.

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 fully covers behavioral traits: it lists the patterns replaced, explains the effect of modes and the 'replace_names' option, and specifies the return format (JSON with 'anonymized' and 'replacements' keys).

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 intro, bulleted list of replacements, and clear parameter explanations. Every sentence adds value, and the format is easy to parse.

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 having only 3 parameters and no annotations, the description covers all necessary context: input, configuration, return format, and behavioral details. The presence of an output schema is acknowledged but the description already specifies the return keys.

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 input schema: it explains that 'content' is the text to anonymize, 'mode' accepts 'full' or 'preview' (enum values not in schema), and 'replace_names' is a boolean flag for heuristic name replacement. This 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 tool scrubs PII from text and returns an anonymized version with a replacement map. It lists specific replacements (patient IDs, GPS, etc.) and distinguishes its function from siblings like 'diff_anonymization' by focusing on anonymization rather than comparison.

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 explains what the tool does and its modes ('full' vs 'preview'), but it does not explicitly state when to use this tool over alternatives or provide usage constraints like required permissions or privacy considerations.

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 traits: it modifies disk content, creates a timestamped backup for revertibility, and updates the proposal database record. No annotations exist, so the description carries the full burden; it does so adequately with clear 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 concise (three sentences plus Args) and front-loaded with the main action. It is well-structured but could be slightly more streamlined by removing the redundant 'writes the proposed change to disk' phrasing.

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 simple one-parameter tool and the presence of an output schema, the description covers the main behavior and side effects. However, it omits potential failure cases or dependencies (e.g., proposal must exist and be in a valid state), which would improve 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 parameter proposal_id is described as 'the id from skill_improvement_proposals', adding crucial context beyond the schema's simple integer type. Despite 0% schema coverage, the description compensates well by explaining the parameter's provenance.

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 explicitly states 'Apply a self-improvement proposal' and details the action: writes proposed change to disk, backs up the previous skill.md, and updates the proposal row. This clearly distinguishes it from sibling tools like 'propose_skill_improvement' or 'reject_proposal'.

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 a proposal is ready to be applied, but it does not explicitly state when to use this tool versus alternatives (e.g., approve_proposal, reject_proposal). No when-not-to-use or prerequisite conditions 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?

With no annotations, the description discloses key behaviors: writing to skill.md, creating a backup first, and marking the proposal as approved. It does not mention edge cases like double-approval, but the main effects are covered.

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

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

Three sentences plus an args line—every sentence is essential. No fluff, front-loaded with the main verb and resource.

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 one-parameter tool with an output schema, the description covers the purpose, input, and side effects. It could mention the return value but an output schema exists.

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%; the description adds meaning: 'The numeric ID from get_pending_proposals()' tells the agent the source and type, beyond the schema's integer 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 the action: approve a pending skill improvement proposal and apply it by writing to skill.md. It names the resource (skill.md) and distinguishes from siblings like reject_proposal and get_pending_proposals.

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 tells the agent that proposal_id comes from get_pending_proposals(), implying the tool is used after retrieving pending proposals. While it doesn't explicitly exclude other contexts, the purpose is 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?

With no annotations provided, the description effectively discloses the mutation behavior (status update), that the item is kept in DB, searchable, and hidden from default view. It does not cover permissions or idempotency, but overall provides sufficient behavioral context.

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

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

The description is concise, with three sentences: a one-line summary, a line explaining the effect, and an Args section. Front-loaded with the main purpose, 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 simple tool with one parameter and an output schema (presumably returning success/failure), the description covers the effect, the parameter, and persistence behavior. No additional information 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?

The single parameter `relative_path` is described as 'the relative_path primary key in library_seeded table', adding critical context beyond the schema's type-only definition (string). 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 tool's purpose: archive a library item by setting status to 'archived'. It distinguishes from hard deletion and from archival of other resources like projects. The verb 'archive' and resource 'library item' are 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?

The description implies usage for items that should be kept but hidden from default view, but it does not explicitly state when to use this tool over alternatives like `remove_library_item`. No prerequisites or exclusions 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?

With no annotations provided, the description carries full transparency burden. It discloses key behaviors: marks inactive, keeps data, sets status='archived', project disappears from active view but remains available for brainstorm context and search. This is thorough, though it omits details on reversibility (inferred from sibling) and permissions.

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 highly concise: 4 sentences. The first explains the core action and effect, the second technical implementation detail, and the third/arg list. No redundant or unnecessary words. Front-loaded with purpose, well-structured.

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 moderate complexity and presence of an output schema, the description covers the essential behavioral effects and usage context. It lacks mention of prerequisites (e.g., existence of project_id) or explicit note about reversibility (unarchive_project exists), but overall is sufficient for an agent to use the tool 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?

Schema coverage is 0% (no descriptions in input schema). The description provides only 'project_id: The project_id to archive.' This adds little beyond the schema's parameter name and type; it does not specify format, source, or constraints. For a single required parameter, this is minimal added 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 the tool's purpose with a specific verb ('Archive a project') and resource ('project'), and explains the effect: marks inactive, keeps data, disappears from active view but remains for context and search. It distinguishes from destructive alternatives like delete/remove, and sibling 'unarchive_project' exists.

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 making a project inactive while preserving data, but does not explicitly state when to use this tool versus siblings like 'remove_project', 'delete_task', or conditions/alternatives. The guideline is implicit in the effect description but lacks explicit 'use when' / 'use instead' clarity.

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 explains that the tool searches a pre-built index and returns a synthesized answer with citations. It implies read-only behavior, but since no annotations are provided, the description could explicitly state that no modifications occur. Nonetheless, it offers sufficient behavioral context.

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

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

The description is well-structured with a brief overview followed by an Args section. It is mostly concise, though the repetition of 'see index_library_pdfs()' could be tightened. Overall, it is efficient and front-loaded.

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 presence of an output schema (not shown but indicated), the description covers prerequisites (index must be built), parameter details, and the core behavior. It is complete for a query tool without requiring additional 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?

With schema description coverage at 0%, the description fully compensates by explaining each parameter in natural language: question ('Natural language question to answer from the library'), top_k (purpose and default), and scope (enumerated values with a note about building the index). This adds substantial 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: 'Answer a question using the user's indexed PDF library via PaperQA2.' It specifies the verb (Answer), resource (indexed PDF library), and method (PaperQA2). This distinguishes it from sibling tools like search_library, which likely performs raw searches without synthesis.

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 when to use the tool: after building the index via index_library_pdfs(). It mentions the index must be pre-built and references the appropriate sibling tool. However, it does not explicitly state when not to use it or compare to alternatives like search_library.

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?

Discloses the 8000 char limit per source and that output includes source labels. However, it does not mention truncation behavior, ordering, or freshness of content. No annotations exist to supplement, so 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 mostly concise, with three short paragraphs. The Args section repeats some information but overall structure is clear 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?

Despite moderate complexity and having an output schema, the description covers core functionality, constraints, and parameters. It is sufficient for basic usage, though edge cases are 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?

With 0% schema coverage, the description adds significant meaning: it lists valid source values and explains the date_filters with an example. Both parameters are well-addressed.

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 assembles context from multiple sources for brainstorming, listing specific source types. This is a clear verb+resource pairing, but it does not explicitly distinguish from sibling tools like 'get_context' or 'surface_relevant_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 on when to use this tool versus alternatives. There are multiple context-retrieval tools among siblings, but the description provides no context for selection.

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 explains the tool is non-destructive (safe while live), details the return JSON fields (backup_path, size_kb, checksum, elapsed_ms), and mentions the API used. This gives good behavioral insight.

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: a single-sentence purpose, a safety note, a bulleted argument list, and a return format summary. Every sentence adds value, and the core purpose is front-loaded.

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 backup tool with 3 optional parameters and a defined output format, the description covers all necessary aspects: what it does, how it works (live-safe), parameter details, and return structure. No 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 0% description coverage (no descriptions in schema), so the description must compensate fully. It does so by explaining each parameter: destination with default path, label for filename suffix, extra_destination for secondary copy. This adds significant meaning beyond the bare 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 creates a timestamped backup of the Metis SQLite database, using a specific verb and resource. It distinguishes from sibling tools like restore_db, list_backups, verify_backup.

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 the tool uses SQLite's Online Backup API and is safe to run while the database is live, providing useful usage context. However, it does not explicitly state when to use this tool vs alternatives like restore_db or encrypt_backup.

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. It describes the return format and steering behavior, but doesn't disclose side effects like session mutation, auth requirements, or rate limits. Adequate but not exhaustive.

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?

Well-structured with purpose, usage, steering modes, then args. Front-loads the key action and context. Every sentence delivers necessary information without 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?

For a 4-parameter tool with an output schema, the description covers all essential aspects: what, when, how, steering options, parameter details, and return fields. No gaps for typical 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?

Schema has 0% description coverage, but the description's 'Args' section fully explains each parameter's purpose, steering values, session continuation, and optional notes. Completely compensates for the schema 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?

Description clearly states 'Run one turn of a brainstorm session' and explains steering modes. It doesn't explicitly differentiate from sibling brainstorming tools like get_brainstorm_session or assemble_brainstorm_context, but the single-turn focus is clear.

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?

Explicitly says 'Call this at the start of a brainstorm and after each steering action', and describes each steering mode's purpose. Lacks explicit when-not-to-use or alternative tool names, but provides strong situational 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 provided, so description carries full burden. It mentions local model and no API key, but does not disclose side effects like whether existing data is overwritten, performance implications, or error cases. The force_rebuild parameter hints at behavior but lacks 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 fairly concise with a logical structure: purpose, model info, database convention, then parameter descriptions. It could be slightly shorter by removing the model details if not critical, but overall 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 an output schema exists (not shown), description need not explain returns. However, it lacks details on prerequisites (database must exist), error handling, or success indicators. For a tool with no annotations, more completeness 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?

Schema description coverage is 0%, so description must add value. It explains 'database' is a slug with examples and 'force_rebuild' means re-indexing already indexed files. This provides useful context beyond the schema definitions.

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 indexes PDFs into a semantic knowledge base using a specific model. It distinguishes itself from siblings like 'create_knowledge_database' which creates the layer, and 'search_pdf_knowledge' which queries. Examples of database slugs further clarify the purpose.

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 database must exist (created via create_knowledge_database()), but gives no explicit guidance on when to use this tool vs alternatives like index_library_pdfs. No mention of prerequisites or when to set force_rebuild.

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 and discloses key behaviors: auto-tagging, linking to domains/projects, and auto cross-pollination. However, it omits details on idempotency, potential destructive actions, or permission requirements, which are important 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?

Description is efficient: a few sentences summarizing behavior followed by a clear args list. Front-loaded main purpose. Could be slightly more streamlined, but overall well-structured and without waste.

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 4 parameters (1 required), no annotations, and a write operation, the description covers primary behaviors but lacks error handling, return value details (though output schema exists), and prerequisites. It is adequate for basic use 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%, so the description must add meaning. It provides minimal explanations for each parameter (content, source, image_path, auto_cross_pollinate) but lacks depth (e.g., valid values for source, path format). This partially compensates but is insufficient for low-coverage scenario.

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 stores an idea in the SQLite ideas table, using specific verb ('Store') and resource ('idea in SQLite ideas table'). It distinguishes from sibling tools like 'get_ideas' (retrieval) and 'capture_observation' (different domain).

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 explains default behavior (auto-cross-pollinate) and the effect of setting auto_cross_pollinate=False. It gives context on when extra connections are provided, but does not explicitly tell when to use this tool vs alternatives like 'capture_observation' 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?

With no annotations, the description explains the purpose and parameter roles but does not disclose side effects, reversibility, authorization needs, or other behavioral traits beyond persistence.

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, front-loaded with purpose, and every sentence adds value. The parameter list is organized and free of 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 the six parameters and no annotations, the description covers inputs thoroughly and explains usage. It omits the return value, but an output schema exists, so this is acceptable.

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 tool description provides detailed explanations for all six parameters, including examples and auto-extraction notes for concepts, adding 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 records observations during an agent run and mentions it helps recall in future sessions. However, it does not explicitly distinguish from similar sibling tools like add_journal_entry or capture_idea.

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 instructs to use the tool 'throughout a run' to capture learning, providing clear context. But it lacks explicit exclusions or alternatives, leaving usage boundaries 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?

With no annotations, the description must convey behavioral traits. It mentions returning status, classification, warnings, but does not state if it modifies state, stores data, or requires permissions. As a scanning tool, it's likely read-only, but this is not explicit.

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?

Extremely concise with a clear purpose sentence and structured docstring. No wasted words; front-loaded with the high-level 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?

Given the presence of an output schema (not shown) and low complexity (2 params), the description sufficiently conveys what the tool does and returns. No further information needed for a scanning tool of this nature.

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 adds meaning beyond schema by defining 'content: Text content to scan' and 'file_path: Optional file path for context-based classification'. This compensates for the lack of 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?

Description clearly states it scans content for PII patterns and classifies sensitivity level, distinguishing it from siblings like anonymize_text (which transforms) and scanning tools (which search for terms). Specific verb+resource.

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 or when not to use this tool versus alternatives. It only describes what it does without context for selection.

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 description carries full burden. It explicitly states NEVER modifies original file, always writes to output_path, default naming convention, and describes the return JSON structure. This fully discloses behavioral traits.

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

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

Well-structured: first line purpose, then immutability note, then bulleted operation list with syntax, then parameter descriptions, then return value. Every sentence adds value without wordiness.

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 0% schema description coverage and no annotations, the description is fully complete. It explains all operations with syntax, parameters with defaults, and return JSON. Output schema provides additional structure but description suffices.

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 description compensates completely. It explains path as absolute local path, operations as list of operation strings with examples, and output_path with default behavior. Adds full meaning beyond 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 it applies cleaning operations to a dataset and writes a new file. It lists all supported operations and explicitly states it never modifies the original file. This effectively distinguishes it from sibling tools like 'suggest_cleaning' or 'profile_dataset'.

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 explains when to use (cleaning a dataset) but does not explicitly mention alternatives or when not to use. While it implies immutability, it does not contrast with other data manipulation tools among siblings.

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, description carries full burden. Discloses mandatory recording checkpoint, enforcement of at least one decision, and separate writes to episodic_memory. Could add details on idempotency or overwrites, but sufficient for safe use.

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

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

Efficient structure: summary sentence, usage context paragraph, then bulleted args. Every sentence adds value. 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?

For a 4-param tool with no output schema and no annotations, description covers all parameters, usage timing, sibling differentiation, and behavioral expectations. No gaps 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?

Schema has 0% description coverage; description compensates with rich guidance: decisions must be 1-5 plain-English with example, summary optional but structured, key_topics with example tags, session_id optional. Adds meaning beyond 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?

Starts with a clear verb+resource: 'Commit key decisions from this session to permanent memory.' Explicitly differentiates from sibling tool save_session_summary by noting this tool enforces decisions and writes to episodic_memory, making purpose distinct.

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?

Directly states when to use: 'call it at the end of every agent-routed session, before delivering the final result to the user.' Contrasts with save_session_summary, providing clear alternative. No guessing 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?

No annotations are provided, so the description carries the full burden. It discloses inputs (two JSON strings), outputs (a JSON with specific fields), and implies a read-only comparison with no side effects. It does not mention authentication or rate limits, but the overview is adequately transparent for a comparison 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 paragraph but effectively covers purpose, arguments, and returns. It is concise without unnecessary words, though it could benefit from bullet points for improved readability. It earns its place with informative 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?

Given the tool has an output schema (mentioned in context), the description does not need to elaborate on return values but still describes the return structure. The two parameters are well-documented, and the tool fits logically among siblings like profile_dataset. The description is complete for an agent to use effectively.

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 schema description coverage at 0%, the description fully explains both parameters: before_profile as a JSON string from profile_dataset() on the original file, and after_profile similarly for the cleaned file. This adds crucial context beyond the schema's basic 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 the tool compares two dataset profiles and produces a side-by-side diff, listing specific outputs (rows/columns added/removed, null count changes, type changes). This distinguishes it from related tools like profile_dataset (which generates a profile) and clean_dataset (which cleans data).

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 explicitly instructs to pass JSON strings from profile_dataset() for original and cleaned files, implying usage after profiling. It does not provide explicit 'when not to use' or alternatives, but the context is clear and sufficient for selecting this tool among siblings.

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. It discloses that Mendeley uses BibTeX export and provides source URLs for Zotero credentials. It does not detail side effects like overwriting existing config or error handling, but the core behavior is clear.

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: a one-line purpose, a usage sentence, then parameter details in an easy-to-scan bullet style. 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?

Given the presence of an output schema (not detailed), the description covers essential aspects: purpose, when to use, and parameter semantics. It lacks mention of return values or failure scenarios, but for a configuration tool, this 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?

Schema coverage is 0%, and the description fully compensates by explaining each parameter: provider options ('zotero' or 'mendeley'), api_key and user_id for Zotero, bibtex_path for Mendeley. It adds valuable meaning beyond the bare 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: 'Configure the library provider for this Metis installation.' It uses a specific verb (configure) and resource (library provider), and distinguishes from siblings like sync_zotero_library and import_bibtex_library by emphasizing setup and switching.

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 explicitly says 'Call this during setup or when switching reference managers,' providing clear context for when to use the tool. However, it does not explicitly mention when not to use it or name alternatives, which would improve 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 burden. It discloses recursive walking, recognized extensions, and the max_files safety limit, but does not cover idempotency, error handling, or authentication needs. The description adds value beyond the schema but is not comprehensive for a mutation tool.

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

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

The description is concise, using four well-structured sentences: main purpose, details on recursion and extensions, usage instruction, then parameter list. Every sentence adds value with 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 tool's complexity (recursive folder walk, extension list, three parameters) and the presence of an output schema (not shown), the description is fairly complete. It explains what the tool does, how to use it, and parameters. Missing details like error handling or idempotency are minor 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?

Schema description coverage is 0%, yet the description provides clear explanations for all three parameters: folder_path (absolute path), label (short label), and max_files (safety limit with default). This adds significant meaning beyond the schema's type/default info, compensating for the lack of 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 clearly states the tool registers all relevant files in a project folder so Metis can read them, specifying the verb 'register', the resource 'project folder', and the outcome 'files added to tracked_files table'. It distinguishes from sibling tools like read_file by providing post-use instructions.

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 explicitly says 'Call this once per project; after that, use read_file() to read any individual file', providing clear when-to-use and when-not-to-use guidance with an alternative named.

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 explicitly states idempotency and details the actions: creating semantic memory nodes with deduplication and pruning working memory older than 7 days, which sufficiently discloses behavioral traits.

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

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

The description is extremely concise, with a front-loaded summary sentence followed by a clarifying paragraph. Every sentence adds value, 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?

Given the tool's moderate complexity and the presence of an output schema, the description covers the core behavior but does not explain prerequisites (e.g., existence of reflexions) or potential return values. The output schema likely covers return info, so it's reasonably 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 clearly explaining the parameters: '>= min_count times in the last `days`'. This adds semantic meaning beyond the schema's 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?

The description uses specific verbs ('distil' and 'prune') and clearly identifies the resource ('recurring reflexion themes into semantic memory' and 'working memory'). It distinguishes itself from sibling tools like aggregate_reflexions_tool by specifying a nightly consolidation process.

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 nightly self-improvement consolidation but does not explicitly state when to use this tool versus alternatives like aggregate_reflexions_tool or consolidate_session_memory. No exclusions or prerequisites 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 provided, so description carries full burden. It discloses deduplication, writing to DB and markdown files, and the filtering logic. However, it does not describe all behavioral traits such as error handling, overwrite behavior, or performance implications. Adds context beyond schema but not exhaustive.

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 concise and well-structured: a one-sentence summary, followed by an explanatory paragraph, then labeled parameter documentation. No unnecessary words, and front-loaded with 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?

Given the tool's complexity (batch operation, dedup, dual output) and presence of an output schema, the description covers key aspects: selection criteria, dedup, and targets. It lacks mention of error conditions or behavior with empty runs, but is mostly 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?

Schema description coverage is 0%, so description compensates fully. It explains each parameter clearly: n_runs as count of runs to review, min_quality with 'high' vs 'all' distinction. This adds semantic meaning beyond the bare schema types and defaults.

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: 'Scan recent agent runs and write structured memory entries.' It clearly distinguishes itself from siblings like add_memory_entry (individual addition) or search_memory (search) by focusing on bulk consolidation from agent runs.

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 context by mentioning 'recent agent runs' and 'high-value work'. It explains the process but does not explicitly state when to use it vs. alternatives like add_memory_entry or when not to use it. Lacks explicit exclusions or direct comparisons.

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. It explains the creation process and layer constraints but does not mention idempotency, overwrite behavior, or error handling for duplicate slugs. Adequate but not comprehensive.

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

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

The description is concise and well-structured: a brief purpose statement, a step-by-step usage note, and a clear parameter list. 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?

The description covers creation steps and parameter details. An output schema exists, so return values are not needed. However, it does not mention success/failure signals or what the tool returns, leaving slight 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?

Schema description coverage is 0%, but the description fully compensates by detailing each parameter: slug (URL-safe identifier), name (human-readable), description (coverage), layer (custom vs built-in), and folders (list of subfolder paths). Examples further clarify usage.

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: 'Register a new custom knowledge database layer.' It uses a specific verb and resource, and it differs from sibling tools like build_pdf_knowledge_db (indexing) and list_knowledge_databases (listing).

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?

Explicit steps are provided: after creating, add PDFs and call build_pdf_knowledge_db. It also explains layer numbering (4+ for custom, 1-3 for built-ins), guiding appropriate usage. However, it lacks explicit when-not-to-use scenarios.

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?

Describes creation of a DB record and its availability for linking and search. No annotations exist, so description carries the burden. It does not mention side effects like duplicate handling, but the behavior is straightforward and non-destructive.

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, focused sentences plus a clear bulleted Arglist. Front-loaded with purpose. No redundancy 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?

Covers creation logic, DB effect, and parameter meaning. Does not mention the output schema, but since it exists, the description is not required to detail return values. Could be slightly improved by noting authentication requirements, but not crucial for this 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 coverage is 0%, but the description's Args section adds meaningful explanations for each parameter: examples for title, length hint for description, domain examples, and source options. This fully compensates for the lack of 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?

Description clearly states the verb 'Register' and the resource 'a new project in the Metis platform', and explains the effect on the DB and UI. It differentiates from siblings like 'create_project_full' by implying this is the standard registration tool.

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 when to call (when researcher confirms permanent tracking), but does not explicitly mention when not to use or compare with the similar sibling 'create_project_full'. The scenario is specific enough 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?

With no annotations provided, the description carries the full burden. It discloses that the tool creates a DB record, CLAUDE.md, and links Claude Desktop, and mentions automatic linking of Claude Desktop config. This provides good behavioral insight, though it could note safety aspects like idempotency or error handling.

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

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

The description is three short paragraphs: purpose, context, parameter list. It is front-loaded with the key action, no redundant sentences, and every sentence contributes to understanding.

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 there is an output schema (not shown but noted as present), the description does not need to explain return values. It covers all six parameters sufficiently, though it could mention prerequisites (e.g., folder existence) or error scenarios. Overall, it is complete for a creation tool with this 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 description coverage is 0%, so the description must add value. It provides a bullet list with explanations for each parameter, including behavior like auto-detection of description when scan_type is not 'none'. This adds meaning beyond the schema's bare JSON types and defaults.

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 'Create a project with full Metis integration: DB record, CLAUDE.md, Claude Desktop.' This is a specific verb+resource+scope, and it distinguishes this tool from siblings like 'create_project' by emphasizing the full integration aspect.

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 says 'This is the unified project creation tool used by all installers and the dashboard.' This gives context for when to use it, but it does not explicitly mention when to avoid it or use alternatives like 'create_project'. The guidance is clear but lacks 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 exist, so the description carries full burden. It only reveals that recurring tasks auto-create next occurrences, but omits other behavioral traits like side effects, authentication requirements, or what happens on validation 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?

The description uses a clear Args structure but is somewhat verbose. The main purpose is not front-loaded; it starts directly with parameter descriptions. Every line adds value, but conciseness could be improved.

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 7 parameters (2 required) and no annotations, the description covers parameter meanings and recurrence behavior but does not mention output schema or return format. It is 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 each parameter's role (e.g., 'owner: Who is responsible (default "Metis")', 'recurrence: Optional repeat...'). It adds meaning beyond parameter 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 explicitly states 'Create a new task in the SQLite database', with a specific verb and resource. It clearly differentiates from sibling tools like add_glossary_term or update_task.

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 update_task or add_journal_entry. The description lacks context about prerequisites, when creation is appropriate, or when other tools should be 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?

No annotations are provided, so the description must fully disclose behavior. It states the tool searches specific tables and returns top 5 items, but does not mention idempotency, permissions, rate limits, or side effects. It implicitly shows it's a read operation but doesn't confirm.

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 at three sentences, front-loading the purpose. It uses bullet-style for the return format and clearly lists the argument. No fluff, though adding structured sections could improve readability.

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 an output schema (not shown), the description adequately covers return values. It specifies the tables searched and number of results. However, with no annotations, missing behavioral details slightly 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?

Only one parameter 'content' with 0% schema coverage. The description adds minimal meaning ('Text to find cross-domain connections for'), but does not elaborate on format, length, or constraints. With low schema coverage, the description should compensate more.

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 finds cross-domain connections for given text, specifies the exact tables searched (library_seeded, meetings, news_briefs, ideas), and describes the return format (top 5 with source type, title, snippet). This distinguishes it from siblings like 'find_connections'.

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 lists the tables searched but does not provide explicit guidance on when to use this tool versus alternatives (e.g., search_library, search_memory). No when-not-to-use or scenarios 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?

Discloses that it appends timestamped lines and keeps a single entry per day. With no annotations, it carries the full burden and does so adequately. Could be improved by noting the return format, but output schema may cover that.

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 args, front-loaded with purpose, no fluff. Every sentence 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?

Complete for a simple append/read tool with one parameter and output schema present. Covers behavior, usage, and parameter semantics.

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 substantial meaning beyond the schema: 'text' is the line to append; leaving it empty reads the note. This compensates for 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?

States exactly what the tool does: append to or read today's daily note. Distinguishes from sibling 'add_journal_entry' by explaining the rolling note vs. new row behavior.

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?

Explicitly contrasts with 'add_journal_entry' to clarify when to use this tool (for daily note capture) vs. creating new journal entries. Also explains that leaving text empty reads the note, indicating a dual read/append use case.

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 covers the binary format, passphrase handling (never stored), default output location, and return value. It lacks details on error conditions but is fairly 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 front-loaded with the core action, then provides format details and Args list. Each sentence serves a purpose, 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 3 params with no schema descriptions and an output schema, the description fully explains inputs, outputs, behavior, and format. No obvious 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?

Since schema coverage is 0%, the description's Args section adds meaning by briefly explaining each parameter's role (enc_path, passphrase, output_path). Could be more detailed but adds 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 explicitly states the tool decrypts .enc backups from encrypt_backup, provides the file format, and explains the output behavior. It clearly identifies the action and resource.

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 indicates this is the counterpart to encrypt_backup for restoration, but does not explicitly state when not to use it or compare to other restore tools like restore_db. Clear context without 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?

With no annotations, the description fully discloses the destructive nature ('cannot be undone'), the action (removes row entirely), and the return value (confirmation or note of non-existence).

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?

Seven sentences, front-loaded with core purpose, no filler. Well-structured: purpose, context, alternatives, prerequisite, return 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 simple deletion tool with one parameter and an output schema, the description covers everything needed: what it does, when to use, how to find the ID, and what to expect in return.

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 coverage, the description explains the single parameter task_id: 'ID of the task to delete (as shown by get_tasks). Required.' This adds crucial context on how to obtain the ID.

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 'Permanently delete a task from the database.', specifying the verb and resource. Distinguishes itself from create_task and update_task by describing its destructive complement role.

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?

Explicitly tells when to use this tool (for tasks created in error or no longer relevant) and when to use update_task instead (to mark work finished). Also provides prerequisite: find task_id with get_tasks.

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 discloses the default scan path but omits behavioral details such as recursion depth, idempotency, side effects, error handling, or what happens if the scan_path is invalid. More transparency is needed for safe invocation.

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

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

The description is three sentences long, front-loaded with the core purpose, and every sentence adds value. No unnecessary words 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?

The description is fairly complete given the tool's simplicity (one optional parameter, output schema exists). It covers purpose, usage guidance, and parameter. However, it does not mention the output format (e.g., list of paths), though the output schema presumably handles that. Slight deduction for not addressing potential recursion or performance considerations.

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 compensates well by explaining scan_path as 'Absolute path to scan' with a default of 'parent of METIS_RC_ROOT'. This adds meaning beyond the schema, which only has a title and default. Slight deduction for not specifying if relative paths are accepted.

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 scans a folder for unregistered git repos and article folders, with a specific verb 'Scan' and resource 'folder'. It distinguishes from sibling tools like 'scan_folder_for_intent' by specifying 'unregistered' and 'not yet tracked in Metis', making its purpose distinct.

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 explicitly indicates usefulness 'for onboarding' and advises to call 'create_project()' for each discovered item. It provides clear context for when to use, though it does not explicitly mention when not to use or list 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?

With no annotations, the description must convey all behavioral traits. It explains the paging parameter behavior (default returns all pages, setting True returns only first page). However, it does not explicitly state that the tool is read-only, nor does it discuss side effects, authentication needs, or rate limits. The examples help but leave 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 concise: a two-line purpose, a bulleted Args section, and three usage examples. Every sentence adds value, and the structure efficiently conveys all necessary information 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's moderate complexity (4 params, 1 required, no enums) and the presence of an output schema, the description covers the key aspects: purpose, parameters, and usage examples. It does not detail the return format, but the output schema covers that. It could benefit from mentioning that the tool is a query (read-only), but overall it is sufficient.

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%, so the description must compensate. It provides clear explanations for all four parameters: resource (with examples), filters (with format and example), fields (with default and nested field example), and paging (with behavior description). This adds significant meaning beyond the bare 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 queries DHIS2 metadata, specifies it is a simplified interface and a wrapper around dhis2_query(), and differentiates from that sibling tool by implying it is for common lookups. Examples further clarify the resource types.

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 positions the tool as a 'convenience wrapper' for common metadata lookups, implying use when a simpler interface is desired over dhis2_query(). It does not explicitly say when not to use it, but the sibling tool name is mentioned, providing 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 provided, the description carries the burden. It mentions authentication, automatic URL prefix handling, and return format (JSON as text). However, it does not disclose potential side effects of write operations (POST/PUT), rate limits, or error behavior, which are important for a tool that can modify 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 well-structured with a summary line, parameter explanations, and examples. It is front-loaded with the core action. While thorough, it could be slightly more concise (e.g., combining explanation and examples), but every sentence 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 the tool has 4 parameters, an output schema (though not shown), and no annotations, the description is comprehensive. It explains all parameters, provides examples, and specifies behavior (authentication, prefix handling, return format). It covers the necessary context for an agent to use the tool 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 provides full parameter documentation via an Args section, explaining endpoint (relative path), params (dict), method (default GET), and body (serialized for POST/PUT). It also gives multiple examples. This adds significant value beyond the bare input schema, which has 0% 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 tool's purpose: 'Make an authenticated API call to the configured DHIS2 instance.' It specifies use cases like metadata validation and data element lookup, and gives concrete examples. This is a specific verb+resource definition that distinguishes it from sibling tools like dhis2_metadata.

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 explicitly lists when to use the tool ('live metadata validation, data element lookup, indicator queries, and data quality checks'). It provides usage examples and parameter guidance, but does not explicitly state when not to use it or compare with alternatives like dhis2_metadata, which would be ideal.

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 burden. It describes the output (plain unified-diff string) but does not disclose side effects, permissions, or error conditions. It's adequate but minimal.

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 sentences front-load the main purpose, parameter descriptions are compact, and every sentence adds value. 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 simple diff tool with 2 parameters and an output schema, the description covers inputs, output format, and intended use. Could mention edge cases like empty strings or large texts, but overall sufficient.

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 0% description coverage, so description adds meaning for both parameters: 'Original (pre-anonymization) text' and 'Anonymized text from anonymize_text()'. This clarifies the expectation beyond bare string 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 the tool returns a unified diff comparing original and anonymized text, with specific verb 'Return' and resource 'unified diff'. It distinguishes itself from sibling tool anonymize_text by being a complementary diff 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 description implies it should be used after anonymize_text by referencing 'from anonymize_text()'. No explicit when-not or alternatives, but the context is clear enough for this simple comparison 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?

Discloses that it is a no-op (returns '') if the intro was already given or tips are off. No annotations provided, but description fully covers behavioral traits.

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

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

Three sentences, front-loaded with purpose, no wasted words. Every sentence 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 parameterless tool with output schema, description covers purpose, usage, and behavior completely.

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; baseline score of 4 applies as per guidelines.

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 it returns a tiny first-run orientation with 3-5 highest capabilities. Distinguishes from sibling tool `next_discovery_tip`.

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?

Explicitly says to use once for a brand-new user or when asked 'what can you do?', then rely on `next_discovery_tip`. Also states it's a no-op if already given or tips off.

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