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

With no annotations, the description carries the full behavioral burden and does not meet it. It implies a mutating build operation with side effects (generating project files via xcodegen, writing build artifacts) but says nothing about permissions, duration, failure modes, or whether it modifies the workspace.

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 single sentence is front-loaded and free of padding, which is good. But its brevity comes at the cost of substance rather than from efficient expression of complete information.

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

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

For a build tool with no annotations, no output schema, and two undocumented parameters, the description is far too thin. An agent cannot tell what the tool returns, what it modifies, or how to invoke it correctly relative to the other iOS tools.

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

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

Schema description coverage is 0% and the description mentions neither 'config' nor 'warnings'. It does not explain the debug/release enum values or what the warnings flag toggles, so it fails to compensate for the undocumented parameters.

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

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

The description names the underlying command (xcodebuild) and implies a build action, which distinguishes it from siblings like ios_install and ios_logs. However, the noun '采集器' (collector) is vague about what is actually produced or gathered, so the agent must guess whether this compiles, gathers build artifacts, or just wraps the command.

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

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

The parenthetical '必要时先 xcodegen' gives a conditional prerequisite, which is the only usage hint present. There is no guidance on when to choose this over ios_env_check, ios_install, or ios_logs, and no statement of required preconditions or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. The '(已脱敏)' note usefully discloses that output is redacted of sensitive data, but it says nothing about whether the operation is read-only, what it returns, or how long it takes. One behavioral hint is not enough for a tool with zero annotation coverage.

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

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

A single compact sentence front-loads the verb and lists the checked resources without filler. Slightly dense given the parenthetical redaction note, but nothing is wasted.

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

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

For a zero-parameter diagnostic with no output schema and no annotations, the description enumerates the inspected surfaces, which is the core information. However, it omits what a caller should do with results and when to invoke it relative to the build/install siblings.

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

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

The tool takes zero parameters, so there is nothing to disambiguate; baseline 4 applies. The description correctly implies no inputs are needed for a full environment sweep.

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 (检查/check) and enumerates the concrete resources inspected: Xcode, signing identities, paired devices, tooling, and project files. This clearly distinguishes it from siblings like ios_build, ios_install, and ios_logs, though it never labels itself a preflight/environment diagnostic explicitly.

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

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

There is no guidance on when to run this versus the sibling ios_* tools; the agent must infer it is a pre-build environment sanity check. No prerequisites, no ordering advice relative to ios_build/ios_install.

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, yet it discloses almost nothing: not whether an existing install is overwritten, whether it fails on an unconnected device, whether it depends on a prior ios_build, or what happens on launch failure. It does convey the mutate-and-launch side effect, which is the only real behavioral signal.

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

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

A single short sentence, front-loaded with the action and target — efficient, but its brevity comes from omission rather than tight editing, so it under-specifies rather than being genuinely concise.

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

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

For a mutation-style tool with zero annotations, no output schema, and 0% schema coverage, the description is far too thin. An agent cannot determine prerequisites, device targeting, or failure behavior from what is given.

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% for two parameters (device, launch). The description mentions 'iPhone' and 'launch' only as narrative, not as parameter semantics: it does not explain how to target a specific device, nor that launching is actually controlled by an optional boolean rather than always happening.

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: install the latest Debug build onto an iPhone and launch it. This is distinguishable from siblings like ios_build (which builds) and ios_env_check, though it never explicitly names or contrasts with 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?

No indication of when to use this versus ios_build or ios_env_check, nor any prerequisite (e.g., a build must already exist, a device must be connected/paired, provisioning required). The agent must infer the whole workflow.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only one trait — that capture is time-bounded to N seconds — and says nothing about whether the call blocks for that duration, where logs are returned or written, or what happens if the device is unreachable.

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

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

A single front-loaded sentence with no filler, which is structurally sound. However, at this length it reads as under-specification rather than true conciseness, since key facts (output destination, defaults) were dropped rather than compressed.

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

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

No output schema, no annotations, and zero parameter documentation mean the description is the only source of truth, and it omits defaults, output format, and device-targeting behavior. For a tool that likely has side effects (writing log files), that is a meaningful shortfall.

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% for both parameters. The description hints that 'seconds' controls duration, but never names it, gives no default (the param is optional) or units beyond the implicit 'seconds', and the 'device' parameter is entirely undocumented in both schema and 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?

The description pairs a specific verb ('抓' / capture) with a specific resource ('采集器运行日志' / collector runtime logs) plus a scope ('N 秒'), so an agent knows it triggers a timed log capture. It does not, however, differentiate itself from neighbours such as ios_env_check or sync_status, which also touch device state.

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

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

There is no guidance on when to reach for this tool versus ios_env_check, ios_build, or ios_install, and no stated prerequisites (e.g. a connected/installed device). The reader must infer the whole usage context from the tool name alone.

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, but it only tells the agent what content exists, not that this is a safe read-only enumeration, whether the list is paginated, or how large it may be. For a zero-parameter enumeration the risk is low, so this is a modest gap rather than a critical one.

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

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

A single short sentence with no filler, and the resource being listed is front-loaded. It is appropriately sized for a trivial zero-arg tool.

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

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

With no output schema and no annotations, the description should at least hint at the shape of the result (identifiers, titles, or counts) so an agent can chain into kb_search. It identifies the corpus but not the return shape.

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

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

The tool takes no parameters, so there is nothing to document; baseline 4 applies. The description correctly implies the call is unconditional.

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 ('列出'/list) and resource ('知识库资源'), and even names the content scope (Apple HealthKit docs + kingstinct reference), so an agent knows exactly what comes back. It does not explicitly contrast with the sibling kb_search, so it falls short of a 5.

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

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

There is no statement of when to use this versus kb_search, which is the obvious alternative for the same knowledge base. The listing intent is only implied by the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only lookup but says nothing about permissions, rate limits, pagination, or result ordering, and gives no sense of what a search response contains.

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

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

The description is extremely short and front-loaded, which is structurally good, but the second sentence merely repeats the schema enum and the whole is under-specified rather than truly 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?

With no annotations, no output schema, and three parameters at 0% schema coverage, the description should explain query semantics and result behavior. It omits both, leaving an agent with insufficient information to invoke the tool confidently.

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

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

Schema description coverage is 0% for all three parameters. The description only restates the enum values for scope, which the schema already encodes, and adds no meaning for q or limit (e.g., matching mode, default page size), so the coverage gap is not compensated.

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

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

The description states a specific verb and resource: full-text search over a knowledge base. However, it does not differentiate this tool from the sibling kb_list, which also operates on the knowledge base, so an agent cannot tell the two apart from the description alone.

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

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

There is no guidance on when to use this tool versus alternatives such as kb_list or query_samples. The only usage hint is the scope enumeration, which selects a data source rather than a scenario, so the agent is left to infer all routing decisions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether logging is additive or overwrites an existing entry, whether timestamps default to now, what permissions are needed, or what happens when only kcal is supplied. For a write tool with zero annotation coverage this is a substantial gap.

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

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

Two compact clauses, front-loaded with the action, with the parameter hint appended. Nothing is padded, though the brevity edges toward under-specification rather than true economy.

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?

A 6-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage gets only a single line of prose. An agent can guess the core intent but lacks the detail needed to populate confidence, ts, photo_path, or note 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 description coverage is 0% across 6 parameters, so the description must compensate. It only clarifies the shape of one parameter, items=[{name,grams,kcal}], and even that omits per-item types. ts, note, confidence, and photo_path remain undocumented in both the schema and the 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?

The description names a specific verb+resource (录入一餐 / log a meal) and immediately distinguishes the two capture modes (photo estimate vs manual). It is clearly separable from siblings like log_workout or query_samples, though it never names an alternative explicitly.

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?

"照片估算或手动" implies the two invocation paths (pass photo_path vs enter items/kcal directly), which is useful implied usage. However there is no statement of when to prefer one over the other, no prerequisites, and no exclusions relative to 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?

No annotations are provided, so the description carries the full burden. It does not disclose required permissions, deduplication behavior, validation rules, what happens with partial data, or what the call returns – all relevant for a write/logging tool.

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

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

A single short sentence with no filler and the purpose front-loaded, but its brevity comes from under-specification rather than disciplined editing – nothing an agent needs to call the tool is covered.

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 six-parameter mutation tool with no annotations, no output schema, and zero schema descriptions, the description is wholly inadequate: required fields, units, and expected behavior are all unstated.

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?

Six parameters with 0% schema description coverage, yet the description names none of them (kind, start, kcal, note, distance_km, duration_min). 'source=manual' is not even a parameter in the schema, so it adds no actionable parameter 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?

States a specific verb and resource ('录入一次运动' = log a workout), which is clearly distinguishable from sibling log_meal and from the read/report tools. It does not, however, differentiate itself from siblings explicitly or state scope (single entry vs batch).

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives (e.g. log_meal for food). The only qualifier, 'source=manual', describes provenance but not a selection condition.

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

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

No annotations are provided, so the description carries the full behavioral burden. '读' implies a read-only operation, but it omits HealthKit authorization requirements, pagination behavior implied by the limit parameter, and return format. Substantial gaps for a data-access 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?

Compact two-clause structure with the core purpose front-loaded, followed by parameter hints. Both sentences earn their place, with only the trailing ellipsis example list slightly loose.

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 5-parameter tool with no annotations and no output schema, the description covers type and agg but leaves limit and the shape of the returned samples unexplained. It is minimally adequate but not complete enough for an agent to call it with full confidence.

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 only 40%, so the description must compensate: it usefully clarifies that type accepts full names or abbreviations with concrete examples (bodyMass, stepCount, heartRate) and explains that agg=daily aggregates by day, adding meaning beyond the bare enum. However, limit remains undocumented in both schema and description, so compensation is incomplete.

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 ('读 HealthKit 样本' = read HealthKit samples), which is clearly distinct from the write-oriented siblings log_workout, log_meal, and sync_status. However, it never names an alternative or scoping condition to differentiate itself from other read tools like weekly_report.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The note that agg=daily aggregates by day hints at a usage mode but stops short of telling the agent when to pick daily vs raw, or when to prefer this tool over 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 provided, the description carries the full behavioral burden. It implies a side-effect-free read by describing only reported values, which is useful, but it does not disclose whether the sync status is fetched live or cached, how often it refreshes, or what error/offline states look like.

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

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

A single, front-loaded sentence with no filler; every clause names a distinct piece of information the tool returns.

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

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

For a zero-parameter status tool with no output schema, the description usefully enumerates the three values returned, which is the main thing an agent needs. It would be stronger if it stated freshness or how to interpret a not-synced state.

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

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

The tool takes zero parameters, so the schema has nothing to document and the baseline of 4 applies. The description's enumeration of returned fields adds context but concerns outputs rather than parameters.

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

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

The description names the resource (the collector's sync status) and enumerates the returned data (library sample count, pending photo count), so an agent knows exactly what question this tool answers. It is not a tautology of the name 'sync_status'. It stops short of a 5 because it uses no explicit verb and offers no contrast with any sibling, though no sibling in the list covers sync state.

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

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

There is no statement of when to call this tool, no preconditions, and no mention of alternatives such as query_samples, which plausibly overlaps with the sample-count data reported here. The agent must infer usage entirely from the returned-field list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the report's content categories (trends, exercise, diet, steps), which is genuine value beyond the schema, but says nothing about read-only safety, whether data freshness/sync matters, or result format. Partial coverage for an unannotated tool.

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

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

A single compact sentence that front-loads the scope ('近 7 天') before the content list. Nothing is wasted, though the extreme terseness leaves no room for routing or behavioral cues that the tool would benefit from.

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

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

With no output schema and no annotations, the description should carry more of the return-value and safety load. It lists the data domains covered, which partially substitutes for an output schema, but omits output shape, freshness/sync dependencies, and any read-only framing. Minimally adequate for a single-parameter report 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 100%, and the sole parameter week_end is fully documented in the schema, including the YYYY-MM-DD/ISO8601 handling and the UTC window definition. The description adds nothing about week_end, so 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 states a concrete resource and scope: a 7-day report covering weight/body-fat trends, exercise, diet, and steps. This is clearly distinct from raw-data siblings like query_samples or log_workout, though it never names or contrasts them explicitly. Purpose is clear but sibling differentiation is left to inference.

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

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

There is no guidance on when to use this tool versus alternatives such as query_samples (raw samples) or log_workout/log_meal (individual entries). The '近 7 天' scope implies a summary use case, but no when/when-not conditions or prerequisites (e.g. data must be synced first) are stated.

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