Apple Health MCP

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds context by specifying it provides guidance on install, runtime, and privacy. However, it does not elaborate on behavioral traits like response size or caching, so value is moderate.

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

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

A single, well-structured sentence that conveys the core purpose without extraneous 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 simple input schema and annotations, the description is minimally adequate but lacks guidance on usage and parameter details. For a tool in a complex ecosystem, more completeness is expected.

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% and the description does not mention or explain the two parameters ('client', 'response_format'). The agent must infer meaning from enum values alone, which is insufficient 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?

The description clearly states the tool provides 'install, runtime and privacy guidance for AI agents operating Apple Health export data,' which is a specific verb-resource combination. It distinguishes from sibling tools by being a manifest file rather than a data query or mutation 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?

No explicit guidance on when to use this tool versus its many siblings. The description implies it's for initial setup or configuration, but there is no mention of alternatives or when not to use it.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive, which covers the safety profile. The description adds useful context about the topics covered (e.g., privacy modes, recommended workflow), but does not disclose additional behavioral traits such as rate limits or data freshness. Given the annotation coverage, a score of 3 is appropriate.

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

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

The description is a single sentence that efficiently summarizes the tool's purpose, listing key topics. It is concise and front-loaded with the verb "explain." However, it could be slightly better structured (e.g., bullet points) for 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?

The description lists the main topics covered (export data, unavailable live access, privacy modes, agent workflow), which is adequate for an informational tool. However, it does not specify the output format or guarantee completeness, and with no output schema, the agent lacks full context on what to expect.

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

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

The input schema has one parameter (response_format) with enum values and a default, but schema description coverage is 0%. The description does not mention the parameter at all, so it fails to add meaning beyond what the schema provides. This leaves the agent without guidance on how to use the parameter effectively.

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 that the tool explains Apple Health export data, unavailable live HealthKit access, privacy modes, and recommended agent workflow. It uses a specific verb ("explain") and identifies the resource, and among the sibling tools, this is the only one focused on capabilities explanation, providing clear differentiation.

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 any guidance on when to use this tool versus alternatives like apple_health_onboarding or apple_health_privacy_audit. It lacks explicit context on prerequisites or exclusions, leaving the agent to infer the appropriate usage scenario.

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

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

Clearly describes destructive action (wipes local cache) and gated by explicit_user_intent. This adds context beyond annotations like destructiveHint and idempotentHint. No contradictions.

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

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

Single paragraph with front-loaded purpose, followed by context. Four sentences with no wasted words, though slightly longer than minimal.

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 cache purpose, file path, auto-invalidation, and user intent requirement. No output schema, but behavior is simple and described well. Lacks explanation of what happens after clearing.

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

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

Schema coverage is 0%, but description does not mention the single parameter 'response_format' or its enum values (markdown/json). Agent gets no guidance on output format 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?

Clear verb 'clear' with specific resource 'incremental import cache' and file path. Explanation of cache purpose and when to use distinguishes from siblings like listing or importing records.

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 states use case: 'force a full re-parse without changing the export file.' Mentions auto-invalidation hinting when not needed, but no explicit alternative tool 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?

Annotations already provide readOnlyHint and idempotentHint, so the safety profile is clear. The description adds useful context about not reading full export data, which is a behavioral constraint beyond annotations.

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

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

Single, concise sentence that front-loads the purpose and key details without waste. Every word adds value.

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

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

For a simple status tool with 2 optional parameters and no output schema, the description covers what it checks but omits details on return format or that it produces a report. It is adequate but missing some 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?

Schema description coverage is 0%, so the description must compensate. However, the description does not explain the two parameters ('client' and 'response_format') at all, leaving their purpose and valid values unclear.

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 'Check' and lists precise items (export path, Node version, privacy mode, Hermes client posture). It also explicitly says it does not read full export data, distinguishing it from data-reading siblings like 'apple_health_list_records'.

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

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

The description clearly implies when to use (to check status before other operations) and what not to use it for (reading data), but does not explicitly mention alternative tools or provide when-not-to-use 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds only a disclaimer ('not medical advice') and mentions local data source, but no additional behavioral traits beyond what annotations provide.

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

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

The description is two concise sentences with no wasted words. The first sentence immediately states the purpose, and the second adds important caveats. Excellent structure.

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

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

Given the tool's simplicity and the annotations covering safety and idempotency, the description provides sufficient context. It clarifies the data source and limitations. The absence of an output schema is acceptable for a summary 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 description coverage is 67% (likely all three parameters have descriptions in the schema). The description does not add parameter-specific meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states that the tool builds a daily wellness summary from local Apple Health export data. It distinguishes from live HealthKit and medical advice, and among siblings there is a weekly summary variant, making the purpose 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 when to use (for a daily summary) and warns that it is not live HealthKit, providing context. However, it does not explicitly state when not to use or how it compares to alternative tools like apple_health_weekly_summary.

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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds behavioral context: it scans a local export once, reports freshness and safe next calls, implying stateful behavior despite idempotency. No contradictions.

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

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

Single sentence of 20 words, front-loaded with action ('Scan the local Apple Health export once'), no redundant words, every part 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?

The description lists all key outputs (record types, workouts, date coverage, freshness, safe next calls) and hints at the one-time nature. No output schema exists, but description adequately sets expectations. Could mention the response_format parameter briefly, but not essential.

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 60%, so baseline is 3. The description adds no parameter-specific details beyond what the schema already provides (start/end/timezone have descriptions). Parameters with enums are not elaborated in description.

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 explicitly states the action ('Scan the local Apple Health export once and report...') and lists specific outputs (record types, workouts, date coverage, freshness, safe next calls). Clearly distinguishes from siblings like apple_health_list_records or apple_health_list_workouts.

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 notes the tool is for a one-time initial scan and mentions it provides 'safe next calls,' guiding subsequent actions. While it doesn't explicitly exclude alternatives or state when not to use, the context is clear given the sibling tools.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true; description adds context that it returns example data, not modifying real data. No contradictions.

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

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

Single sentence front-loads key purpose. Could be improved by including parameter info, 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?

Covers main purpose for a simple demo tool, but missing parameter documentation reduces completeness. No output schema, but description 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?

Description does not mention the response_format parameter despite 0% schema coverage. Parameter has enum and default but should be explained in description.

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

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

Description clearly states the tool returns realistic example payloads for specific summary types. Uses specific verb 'Returns' and resource 'example payloads', distinguishing it from sibling tools that provide real 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?

Implicitly suggests use for testing/understanding contract before real parsing. Does not explicitly state when not to use, but context with sibling tools makes it 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds the staleness algorithm (30 days or 7 days with no recent records), which is beyond what annotations provide. No contradictions.

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 and returns, then staleness logic, then usage. No unnecessary 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?

Given the simple tool, the description covers purpose, return values, staleness criteria, and usage context. No output schema needed as description explains output. Annotations cover behavioral traits. 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%, but the only parameter (response_format) is self-explanatory from its enum and default in the schema. The description does not mention it, but the schema is sufficient. Baseline 3 is appropriate.

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

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

The description clearly states the tool checks export freshness, returns mtime, days_since_export, is_stale flag, and recommendation. It specifies staleness criteria, making the purpose distinct from sibling tools like apple_health_daily_summary.

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 instructs to use this tool before relying on apple_health_daily_summary or apple_health_wellness_context to confirm export freshness, providing clear when-to-use and 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?

Adds substantial context beyond the annotations: the full-file scan cost model (~33 ms per MB, ~3 s for 84 MB), in-memory caching of identical queries, the fact that `limit` caps only the returned list and not the aggregate, and the nested `numeric` statistics shape. This far exceeds the bar set by readOnlyHint/idempotentHint and does not contradict them.

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?

Dense and front-loaded: purpose and the critical `limit` caveat come first, followed by cost and mode guidance. Slightly long, but every sentence carries operational weight — the COST block, caching note, and mode routing all earn their place.

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

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

For a complex tool with 7 parameters and no output schema, the description is thorough. It covers the return shape (truncated/limit_applied/matched_count and nested numeric stats), the cost model, caching, and mode behavior. Little an agent needs to call it correctly is missing.

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

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

Schema description coverage is only 57%, leaving limit, privacy_mode, and response_format undocumented in the schema. The description compensates by explaining `limit` semantics (caps the list only, not the aggregate), the three privacy modes and their behavior, and the aggregate block's nested structure. This is meaningful value added 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?

States a specific verb and resource: 'List bounded records from a local Apple Health export.xml.' It is distinguishable from siblings like apple_health_list_workouts (workouts only) and apple_health_daily_summary (aggregated view) by focusing on raw record listing with type/start/end filters. However, it never names a sibling explicitly, leaving the agent to infer the distinction.

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?

Offers explicit mode-selection guidance — 'For a cheap bounded page with no full-file scan, pass privacy_mode "structured" or "raw"' — and spells out the cost tradeoff of summary mode versus the cached repeat-query path. It does not explicitly exclude sibling tools (e.g., when to prefer list_workouts), so the alternative-routing guidance is intra-tool rather than cross-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?

Annotations already indicate readOnly, idempotent, non-destructive. The description goes far beyond by disclosing the cost of reading the whole file per query (with timing estimates), caching of identical queries, that start/end do not shorten the read, and that limit only caps the list not the aggregate. This is exceptional transparency about performance and semantics, fully complementing the annotations.

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 long but every sentence earns its place. It is front-loaded with the primary purpose, then systematically covers limit semantics, cost, and caching. The structure is logical and efficient, with no filler or repetition.

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

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

For a tool with 5 optional parameters, no output schema, and rich behavioral nuances, the description covers all critical aspects: purpose, parameter effects, performance cost, caching, and what the aggregate block returns. An agent can safely call this tool and interpret the response without additional clarification.

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 only 40% (end and start). The description significantly compensates by detailing the `limit` parameter's exact effect (caps the list, not the aggregate) and explaining the aggregate block fields and truncation indicators. It does not explain privacy_mode or response_format beyond their enums, but the default mention of summary mode adds context. Overall, it 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 it lists workouts from a local Apple Health export.xml, specifying the resource and source. It distinguishes the tool from siblings like apple_health_list_records by focusing on workouts, and the detail about privacy modes and aggregate behavior makes its purpose unmistakable.

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

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

The description provides clear context on when to use it (to list workouts from an export) and important usage constraints (bounded list, cost implications, caching behavior). It does not explicitly name alternative sibling tools or say 'use X instead', but the purpose and cost notes effectively guide usage without confusion.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description reinforces 'Read-only — does NOT persist anything' and adds context about returning 11 questions, profile state, missing fields, and cross-connector sharing, adding value beyond annotations.

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 with no wasted words. First sentence states core purpose, second reinforces safety, third gives pairing guidance and cross-connector note. Front-loaded and efficient.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description adequately covers what is returned (onboarding flow, profile state, missing fields) and how to use it (pair with update). Minor omission: no description of response format differences, 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 description coverage is 50% (locale described, response_format missing). The tool description adds no parameter information, failing to compensate for the gap. The response_format enum values 'markdown' and 'json' are not explained, leaving ambiguity.

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

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

The description clearly states the tool returns the 11-question onboarding flow plus current profile state and missing fields. It specifies the verb 'return' and resource, and distinguishes from siblings like apple_health_profile_get by including the onboarding flow.

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 advises pairing with apple_health_profile_update after user answers, providing clear usage context. Lacks explicit when-not-to-use guidance, but the pairing instruction sufficiently differentiates from alternative tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the important behavioral constraint 'without revealing health data', which is not captured in annotations, enhancing transparency about privacy preservation.

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

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

Single sentence that is front-loaded with the core purpose. No wasted words, every phrase 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?

Given simple parameter set, rich annotations, and no output schema, the description sufficiently covers the tool's purpose and safety. Lacks detail on return format but that is partially addressed by the response_format parameter.

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 should compensate. However, the sole parameter (response_format) with enum and default is self-explanatory. Description adds no additional meaning beyond the schema, justifying a baseline score of 3.

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

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

The description clearly states the tool returns 'the local privacy and export-file posture', a specific verb-resource pair. It distinguishes from siblings by emphasizing 'without revealing health data', contrasting with tools like apple_health_data_inventory that might expose 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 implies usage for privacy audits without exposing data but provides no explicit guidance on when to use this versus sibling tools like apple_health_export_freshness or apple_health_data_inventory. No when-not-to-use or alternative recommendations.

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?

Annotations already declare readOnlyHint and destructiveHint; description adds useful safety context (no OAuth secrets, no cloud auth) that goes beyond annotations. No contradictions.

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 two sentences, front-loaded with purpose. The second sentence contains multiple pieces of information but remains efficient. Slightly verbose with the security detail but still concise.

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

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

Covers main purpose, readability, safety, and lists returned fields. Although no output schema, the description adequately describes return values. Does not mention how the response_format parameter affects output.

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 only parameter (response_format) is not mentioned in the description. With 0% schema description coverage, the description fails to add meaning beyond the schema for this parameter.

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

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

Clearly states the tool reads the Delx Wellness profile from a specific local file path. Differentiates from siblings like apple_health_profile_update by emphasizing read-only nature.

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

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

Provides context about security (no OAuth tokens, local-export) and declares read-only, which helps guide usage. However, does not explicitly state when not to use or reference alternatives beyond the read-only hint.

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 all annotations false, the description carries the full burden. It discloses that the tool is a partial patch operation, requires explicit_user_intent, and rejects secret-like fields at write time. It does not mention idempotency or success/failure responses, but still provides substantial transparency beyond the raw schema.

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, each adding distinct value: action and file, requirement and constraint, usage examples. No wasted words, and the most important information 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?

Given no output schema and three parameters (one nested), the description covers purpose, usage, and key behaviors. It doesn't mention return format or success/failure handling, which is a minor gap, but overall it is sufficiently complete for an agent to use correctly.

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

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

The description adds meaning beyond the schema by explaining that the 'patch' parameter is used for recording specific fields (preferred name, goals, etc.) and by stating that secret-like fields are rejected. The 'explicit_user_intent' parameter is reinforced. Schema coverage is 67%, so the description compensates well.

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

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

The description uses a specific verb ('persist a partial patch') and resource ('~/.delx-wellness/profile.json'), clearly distinguishing it from sibling tools like apple_health_profile_get. It also lists the kinds of data to record, making the purpose unambiguous.

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

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

The description explicitly states a critical usage condition ('Requires explicit_user_intent=true') and a constraint ('rejects secret-like fields'), and provides examples of when to use it. It doesn't explicitly state when not to use it or list alternatives, but the context is clear enough.

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

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

The description adds significant value beyond annotations by detailing adaptive behavior based on the current state (e.g., APPLE_HEALTH_EXPORT_PATH existence/parse validity) and emphasizing the local-first, server-free nature. This complements the annotations (readOnlyHint, idempotentHint) without contradiction.

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

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

The description is extremely concise—two sentences that front-load the core purpose and immediately follow with critical usage guidance and behavioral traits. Every sentence is essential 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 the tool's low complexity (single optional param, no output schema, clear purpose), the description covers all necessary context: purpose, usage scenario, state adaptation, and privacy guarantee. It is fully complete for an agent to understand when and why to invoke 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?

With only one simple parameter (response_format) that has a clear enum and default, the schema already defines it adequately. While the description does not mention the parameter, the lack of need is justified by the parameter's simplicity and self-explanatory nature. No additional explanation is necessary.

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 ('Personalized 3-step setup walkthrough for the human user') and identifies the resource ('Apple Health connection'). It also distinguishes from siblings by specifying to call it first when the user asks about connecting Apple Health.

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 instructs to call this tool first when the user asks 'how do I connect Apple Health?', providing clear context. However, it does not mention when not to use it or suggest alternative tools, which could be helpful given the presence of sibling tools like apple_health_connection_status and apple_health_onboarding.

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?

Annotations indicate readOnlyHint=false, which the description supports by detailing state changes: 'promoted to the active export, the in-memory snapshot cache and incremental cache are cleared.' It also explains check_only behavior and force parameter effects. No contradictions; the description adds valuable behavioral context beyond annotations.

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 containing all necessary information without excessive verbosity. It could benefit from bullet points or clearer separation of behaviors, but it is efficiently written and front-loaded with the core action.

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

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

Given the tool has 3 parameters and no output schema, the description covers scanning, promotion, cache clearing, force, check_only, and distinguishes from the native bridge. It also mentions the setup path and required permissions. For its complexity, it is 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?

Schema coverage is 67%, and the description adds meaning: for 'force' it explains 're-promote the newest export... even if it already matches the active export (forces a cache refresh)'; for 'check_only' says 'report the watch-folder status without promoting a new export.' The 'response_format' is already described in schema. The description compensates well for the missing schema descriptions.

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

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

The description clearly states the tool's action: 'Re-scan the configured watch folder... for a newer Apple Health export.' It specifies the resource (watch folder) and the verb (re-scan and promote). It distinguishes from siblings by noting it's the 'cross-platform recurring-refresh path' and that the native HealthKit bridge is separate, avoiding confusion.

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 usage context: 'the cross-platform recurring-refresh path — the native HealthKit bridge needs macOS and is separate.' It also indicates when not to use it: 'Requires explicit user intent when promoting a new export (force or non-check_only); check_only is read-only inspection.' It doesn't explicitly enumerate alternatives but gives clear guidance on intent.

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?

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behaviors. The description adds context that the tool uses locally exported data (not live API) and includes a disclaimer about non-medical advice, which goes beyond annotation information.

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

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

The description is two sentences: the first states the core action, the second adds disclaimers. It is front-loaded, concise, and contains 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?

Despite having 5 optional parameters and no output schema, the description does not explain what the summary includes (e.g., metrics), how parameters like privacy_mode or response_format affect output, or prerequisites like requiring an export. The annotations cover safety but leave functional details missing.

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

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

Schema coverage is low (40%), with only end_date and timezone having descriptions. The tool description does not mention any parameters or their meanings, failing to compensate for the gaps in schema documentation.

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 builds a weekly wellness summary from local Apple Health export data, with disclaimers about not being live HealthKit or medical advice. However, it does not explicitly differentiate from sibling tools like apple_health_daily_summary or apple_health_wellness_context, though the name implies a weekly scope.

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

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

The description implies usage for local export data and weekly periods, and disclaims live HealthKit and medical advice. However, it provides no explicit when-to-use or when-not-to-use guidance, nor mentions alternatives like daily_summary for single-day needs.

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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds context about data transformation into a specific shape, which is valuable but does not disclose any additional behavioral traits such as side effects or prerequisites. With annotations covering the core safety profile, this is adequate.

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

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

The description is a single sentence that concisely conveys the core purpose without extraneous information. It is front-loaded with the verb and resource. However, it could be more structured by adding parameter hints or usage context.

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 6 optional parameters, no output schema, and a moderate-complexity tool, the description is minimally adequate. It explains the high-level purpose but lacks details on the output shape, normalization logic, and parameter roles. For an agent to use it effectively, more context is needed.

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

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

Schema description coverage is only 33% (only date and timezone have descriptions). The tool description does not mention any parameters or explain their semantics, leaving the agent to rely only on the schema. Since coverage is low, the description should compensate but does not.

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

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

The description clearly states the action (Normalize) and the specific resource (local Apple Health export sleep, workout and activity data) and the outcome (shared wellness_context shape for recommendation engines). It distinguishes itself from sibling tools by mentioning the specific output format, but it does not explicitly differentiate from similar transformation tools like apple_health_daily_summary.

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 any guidance on when to use this tool versus alternatives, nor does it specify prerequisites or exclude conditions. An agent has no context to decide between this and apple_health_daily_summary or other sibling tools.

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