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

No annotations are provided, so the description carries the full burden of disclosing side effects. It says 'register', implying a state-changing operation, but does not mention consequences, reversibility, required permissions, or the significance of the dry_run option. The risk profile is only hinted at through the parameter 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?

The description is a single concise sentence with no filler, and the core action is front-loaded. However, it is terse enough that some meaning is lost, particularly for readers unfamiliar with FDE deliverables and enterprise SubAgents.

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

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

The tool has no annotations and no output schema, so contextual completeness depends heavily on the description. The description does not define key domain terms, explain what activation means, or clarify how dry_run and node_filter affect the outcome. An agent could select the tool but would need external knowledge to call it confidently.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain dry_run and node_filter. The tool description itself adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific action: reading FDE deliverables and registering an enterprise SubAgent. This is distinct from sibling tools like workflow_submit or fde_deploy, but it leaves the relationship between 'activating a workflow' and these actions implicit.

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 workflow_submit, workflow_create, or fde_deploy. No conditions, prerequisites, or exclusions are provided, so an agent must infer usage from the name and schema 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?

With no annotations provided, the description must carry the behavioral burden. It discloses a key limitation (does not include private key), which is useful, but it does not describe any permission requirements, return format, or error cases. For a simple query tool, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It communicates scope, target, and a critical exclusion (private key) in just a few words, achieving maximum information density.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description covers the essential usage context: what it returns (identity code), its scope (self or others), and an important safety note (no private key). An agent can invoke it correctly with the available information.

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

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

The schema describes parameter agent_id as '目标 Agent 身份码（缺省 = 查自己）' (target agent ID, default = self), and the tool description reinforces this by stating '查自己或他人' (query self or others). This adds semantic context beyond the schema, such as default behavior and scope, even though schema coverage is high at 100%.

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 '查询' (query) and a specific resource 'Agent 身份码' (Agent identity code). It clarifies that it can be used for self or others and explicitly excludes the private key, making its purpose unambiguous and distinct from sibling tools like list_agents or create_agent.

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 it (querying an agent's identity code, for self or others) but does not explicitly state when not to use it or name alternative approaches. While it is clear from context, there are no exclusions or explicit differentiation from similar 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'run data audit', revealing nothing about side effects, read-only semantics, return format, permissions, or whether D1-D5 levels have different behaviors.

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 succinct sentence with no filler. It is front-loaded and gets to the point immediately, though it sacrifices detail for brevity.

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

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

For a tool with three parameters, an enum scope, no output schema, and several similar siblings, this one-sentence description is incomplete. It omits what D1-D5 denotes, return value expectations, and how scopes affect the audit.

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 100%, so the baseline is 3. The description adds no parameter semantics beyond the schema; it doesn't clarify scope semantics or the meaning of D1-D5.

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 pair: runs a data audit on knowledge base structured data changes, and references D1-D5, which distinguishes it from sibling tools like audit_file, audit_trail, and run_audit by naming the target 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 guidance is provided on when to choose this over the many sibling audit tools (audit_file, run_audit, audit_trail). The description neither states conditions for use nor exclusion criteria, leaving the agent to infer from the resource name.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is non-blocking ('不阻断') and returns structured results ('返回结构化结果'), which are useful behavioral traits. However, it doesn't mention side effects (e.g., whether it modifies anything), permissions, or the exact structure of the return. For an audit tool, the non-blocking and structured-result info is helpful but not comprehensive.

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

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

The description is a single, compact sentence that front-loads the core purpose and key behavioral notes (non-blocking, structured results). There is no wasted text; every clause earns its place. This is highly 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?

For a relatively simple tool with 4 parameters, full schema coverage, and no output schema, the description covers the essential usage context: when to call, what it does, and the non-blocking nature. It doesn't describe the output format in detail, but since there's no output schema, some guidance might be expected. However, for an audit tool, the structured result is implied to be a standard response. Overall, adequate for correct invocation, though a bit more detail on the return would elevate it.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters. The description adds no additional parameter semantics beyond what the schema already provides (e.g., diff for content-level rules, task for context rules are already in the schema). At baseline 3, since the schema does the heavy lifting and the description doesn't compensate further.

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

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

The description states a specific action ('审计' - audit) on a specific resource ('单文件变更' - single-file change), and clarifies the trigger context ('Agent 编辑文件时调用'). It differentiates from siblings like run_audit or audit_data_change by emphasizing '单文件' (single file), though it doesn't explicitly name alternatives. Clear but not fully differentiated.

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

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

Provides a clear trigger condition ('Agent 编辑文件时调用') and scope ('跑单文件适用规则'), indicating it's for single-file edits. However, it doesn't explicitly state when NOT to use it or mention alternative tools, so it lacks explicit exclusions. Clear context, no alternatives mentioned.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does add one useful behavioral detail — 'HMAC 验签' (HMAC signature verification) — which tells the agent results are integrity-checked. However, it does not state whether the operation is read-only, describe the response format, or mention pagination/limits; for a query tool with zero annotation coverage these are notable gaps.

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

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

A single efficient sentence that front-loads the purpose ('跨设备审计轨迹查询') and places the HMAC detail in parentheses as secondary. No wasted words; only a brief routing note would have made it a 5.

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 2-parameter query tool with full schema coverage this is mostly adequate: purpose, parameter defaults, and a behavioral note are covered. But it omits differentiation from the several audit-related siblings and any indication of the return shape (no output schema exists), leaving gaps an agent must resolve elsewhere.

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%, so both parameters (agent_id and include_peers) are already documented with defaults in the schema. The description's '完整轨迹' and '跨设备' loosely map to these parameters but add no syntax or format details beyond the schema, so it sits at the baseline 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 states a specific verb ('查询'/query) and resource ('跨设备审计轨迹'/cross-device audit trail), scoped by agent_id. It is clear about what it does, but it does not explicitly differentiate from audit-related siblings such as run_audit, audit_file, and audit_data_change — the cross-device qualifier only implicitly separates it.

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

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

There is no guidance on when to use this tool versus the audit siblings (run_audit, audit_file, audit_data_change, worklog_query). No when-to-use, when-not-to-use, or alternative routing is given; usage context is only implied by the tool's name and one-line description.

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 for behavioral disclosure. It only states that conditions are run and a structured result is returned, but does not disclose whether execution has side effects, requires permissions, or how the structured result is shaped. This is underspecified for an execution 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 front-loaded sentence with no filler. The purpose is stated first, and the return characteristic is included succinctly. It 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 only two parameters and full schema coverage, the description is minimally viable for selecting and invoking the tool. However, there is no output schema and no annotations, and the description only promises 'structured result' without explaining its fields or execution side effects, leaving meaningful 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 100%, so the burden on the description is low and the baseline is 3. The description adds the useful link to define_acceptance-registered conditions, but it does not add material parameter meaning beyond the schema descriptions already present.

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

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

The description names a specific verb and resource: 'run the conditions registered by define_acceptance' and says it returns a structured result. This clearly distinguishes it from the sibling define_acceptance (registration) and other evaluation tools.

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

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

The description implies the correct usage context: check_acceptance is for executing acceptance conditions previously registered by define_acceptance. It gives clear context, though it does not explicitly list alternatives or when-not-to-use cases.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the 'full' action persists promoted rules, what side effects occur, what the tool returns, or whether operations are reversible.

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 compact sentence with no filler, and the core purpose is front-loaded. However, it is so terse that some behavioral details are missing, which slightly reduces effectiveness.

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 an unannotated tool with no output schema, this one-line description is incomplete. It does not explain what a rule candidate looks like, whether call logs are read automatically or supplied via case_texts, what the full promotion step changes, or what the response contains.

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%, so the baseline is 3. The description adds the source context ('commons logs + Refine loop') but does not meaningfully elaborate on the action or case_texts parameters beyond what the schema already states.

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 action and resource: '从公地调用日志 + Refine 循环提炼质量规则候选' (distill quality rule candidates from commons call logs + Refine loop). This distinguishes it from generic siblings, though it does not explicitly contrast with closely related commons_* or refine tools.

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

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

The description gives no explicit when-to-use guidance or alternatives. The action parameter explains the harvest vs full modes mechanically, but not the conditions that would make an agent choose this tool over refine or other commons_* 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 behavioral burden. It discloses two non-obvious behaviors: SkillScan interception and HITL confirmation, which adds meaningful context beyond the schema. However, it does not explain what these entail, such as whether the call blocks, who must approve, or what happens if confirmation is declined.

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, tight sentence with the core action front-loaded and behavioral flags in parentheses. There is no filler or repetition, though it could be slightly more structured 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?

There is no output schema or annotations, and the description omits the expected return shape, execution model (synchronous vs job-based), and the operational impact of SkillScan/HITL. For an invocation tool that may be intercepted and require human confirmation, these are material gaps that an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so the structured data already documents all three parameters. The description adds only that input is passed through ('透传给被调能力') and that capability_id must be discovered first; it does not clarify the expected shape of input or how caller_agent_id is used. This is adequate but not compensatory.

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 identifies a specific action ('调用' invoke) and resource ('能力' capability), and situates it in a lifecycle step ('发现能力后' after discovery). It is distinguishable from siblings like commons_search and commons_rate, though it does not explicitly name 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 explicitly states the precondition to invoke only after discovering the capability, reinforced by the capability_id parameter doc '先 commons_search 发现'. It does not enumerate exclusions vs alternatives like commons_rate or commons_retire, but the lifecycle cue is clear 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?

No annotations are provided, so the description must carry the full behavioral burden. It mentions a 'SkillScan security gate' but does not explain what that entails (e.g., approval flow, failure consequences, side effects). It does not disclose whether the operation is reversible, what permissions are required, or what happens after publishing. This is insufficient for a mutation-like operation.

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

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

The description is a single short phrase that front-loads the core purpose. There is no fluff or redundant information, making it highly concise and efficient.

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

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

The tool has a nested object parameter with eight fields and no output schema. The description does not explain expected outcomes, prerequisites (e.g., valid owner, existing sourcePath), or how the security gate affects the operation. An agent would not know what to expect after calling it. This is incomplete for a complex publish operation.

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

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

Schema description coverage is 100% because the metadata parameter's description lists all subfields. The tool description adds no additional parameter semantics; it does not explain how metadata is used or provide any context beyond the schema. Baseline 3 is appropriate since the schema already documents everything.

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 (publish) and the resource (Skill/Agent/Flow) to a specific destination (enterprise capability commons), and mentions a distinguishing detail (SkillScan security gate). This is a specific verb+resource that differentiates it from sibling tools like commons_rate or commons_retire.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or comparison with siblings such as commons_rate or commons_retire. The purpose is implied by the verb 'publish', but no explicit usage context is given.

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

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

With no annotations, the description carries the full burden. It does disclose that the tool accumulates a score after invocation and has anti-spam/anti-abuse protections, which is useful behavioral context. However, it does not mention side effects on trust, idempotency, rate limits, or permissions, leaving significant behavior undisclosed.

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

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

The description is very short and front-loads the core purpose and key constraint. The lead phrase “能力评价” partly restates the tool name, but the rest of the sentence adds meaningful behavior, so it remains efficient.

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

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

For a simple 5-parameter rating tool with full schema coverage, this is minimally viable. It lacks explicit guidance on the exact invocation trigger, the effect on capability trust, and the expected result, but the schema plus the brief description provide enough for a straightforward call.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds only the score range (0.0~1.0), which duplicates the schema, and provides no additional meaning for rater_id, capability_id, or owner_agent_id beyond what the schema already states.

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 identifies the resource (capability) and the action (rate/evaluate) with a clear score range. It is distinct enough from the sibling tools like commons_invoke or commons_publish, though it uses the noun-like phrase “能力评价” rather than a strong verb and does not explicitly contrast itself with any sibling.

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 this tool should be used after a capability invocation, but no explicit when-to-use or when-not-to-use guidance is given, and no alternative tools are named. Usage context is only lightly implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation is non-destructive ('不删除，可恢复') and requires owner confirmation, which is useful. However, it doesn't explain side effects, the scan action's behavior, or whether restore has similar constraints. Partial 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?

A single, concise sentence that front-loads the core action and key constraints. No wasted words, and it is appropriately sized for the tool's complexity.

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 three actions (retire, restore, scan) and required owner confirmation, the description omits details about the scan action and the overall workflow (e.g., how confirmation is obtained, what happens after retirement). The schema covers parameter semantics but not the tool's behavioral flow. Somewhat incomplete.

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

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

Schema coverage is 100% with each parameter having a description. The description adds no additional meaning beyond the schema, but since the schema is thorough, the baseline of 3 is appropriate. It doesn't compensate for any gaps because there are none.

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 (retire/restore) and resource (capability), explicitly distinguishes from deletion by noting 'not delete, recoverable', and clarifies the owner confirmation requirement. Clear and non-tautological.

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

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

No guidance on when to use this tool vs alternatives. It doesn't mention any sibling tools or conditions for use. The description only states what it does, leaving the agent to infer applicability.

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

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

No annotations exist, so the description carries the full burden for behavioral disclosure. It only states the search purpose and filter axes; it does not mention returning results, pagination, read-only safety, permissions, or any operational behavior beyond the act of searching.

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

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

The description is a single front-loaded sentence with no filler. It is efficiently sized for a simple search tool, though its brevity leaves some behavioral and usage gaps.

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 explain what the agent should expect from invoking the tool. It does not describe return shape, scope of results, or any constraints. The schema covers parameters well, but the description is too thin to be fully actionable on its own.

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%, so the baseline is 3. The description's tag/keyword/type phrasing loosely maps to tag/query/kind but adds no semantic detail beyond what the schema already documents, such as tag priority over query.

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 a specific verb ('检索' = retrieve/search), a resource ('能力公地' = capability commons), and the three filter dimensions (tag/keyword/type). It is clear on its own but does not explicitly distinguish itself from sibling tools like list_capabilities or search_knowledge.

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

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

No guidance is given about when to use this tool versus alternatives. Sibling tools such as list_capabilities or search_knowledge overlap conceptually, yet the description offers no exclusions, conditions, or routing hints. The only usage clue is the implied filtering behavior in the description.

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 disclosure burden. It adds valuable behavioral traits: the operation is read-only ('只读'), responses are tenant-isolated ('只返回请求租户条目'), and the result contains only connector entries, never mixed with MCP tool listings. It does not cover error cases or pagination, but for a simple list tool 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 compact and front-loaded with the main purpose and filters. The parenthetical 'G5b 目录面' is an obscure project reference that adds little for an AI agent, but the rest is efficient and free of 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 filtered-list tool with four optional parameters and no output schema, the description covers the essential context: purpose, filters, tenant behavior, read-only nature, and output content scope. It does not describe the return shape or pagination, but given the simplicity of the tool and the absence of annotations, it is 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?

Schema description coverage is 100%, so the baseline is 3. The description restates the filter parameters (type, host, capability) and tenant isolation, but it does not add material meaning beyond the schema's property descriptions. No extra parameter semantics are provided.

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

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

The description clearly states the verb 'discovery' and the resource 'connectors', and specifies the filtering dimensions (type, host, capability) and tenant isolation. It also explicitly distinguishes itself from the MCP tool list ('与 MCP 工具清单（TOOLS）分列，绝不混列'), making its purpose unambiguous against siblings like list_capabilities or list_agents.

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 for when to use the tool: to discover connectors filtered by type/host/capability, with tenant isolation. However, it does not explicitly name alternative tools or state when not to use it, leaving the when-not-to-use part to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses a complete pipeline: plugin-gate whitelist validation (with rejection outside whitelist), persistence to config/connectors.json with tenant isolation and duplicate-name rejection, and audit trail. This goes well beyond the schema, revealing side effects and failure conditions.

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

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

The description is a single dense sentence that front-loads the core action, then uses arrows to efficiently present the pipeline (whitelist → persistence → audit) and ends with the connector_list reference. Every element earns its place 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?

It covers the admission process, persistence, audit, failure conditions, and sibling tool routing. The main gap is the absence of a stated return value/response format, which is more relevant since there is no output schema; the description nevertheless provides enough context for safe 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 coverage is 100%, so the baseline is 3. The description reinforces the source whitelist requirement and names uniqueness constraints, but it adds no new semantics for name, kind, tenant, endpoint, or capabilities beyond what the schema already describes.

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 and resource: '注册第三方连接器' (register third-party connector). It also differentiates from tool registration ('与工具注册分列') and points to connector_list for listing, giving a specific verb-resource pair and distinguishing it from siblings like connector_list and device_register.

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 separates this from tool registration and directs listing to connector_list, which are clear usage hints. However, it doesn't provide a detailed conditional for when to choose this over other resource-registration tools (e.g., device_register, model_register) beyond the connector resource type, so it is clear but not exhaustive.

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 explicitly states '纯读零写入' (pure read, zero writes), which is a clear behavioral disclosure, especially important because annotations are absent. It also reveals the aggregation logic and cross-tenant filtering behavior. It does not cover permissions or rate limits, but for a read-only tool this is 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?

The description is a single, dense sentence that front-loads the core purpose and ends with the read-only guarantee. It packs multiple pieces of information without being verbose, though the G7 linkage reference may be cryptic to an external agent.

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 is a read-only report query, the description covers the essential purpose, aggregation logic, and read-only nature. However, without an output schema, it does not describe the return format or structure of the report, and 'G7 linkage' is left unexplained. For a query tool this is adequate but not 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 100%, so all three parameters (org_id, data_dir, window_days) are already documented in the input schema. The description adds no new parameter-specific detail beyond what the schema provides—for example, the schema already explains org_id's tenant isolation. The baseline of 3 applies.

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

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

The description clearly states the tool produces a contribution report (贡献度报表) with a specific aggregation formula (PR weight + decision trace + audit change scale → comprehensive contribution score) and two output dimensions (by person, by workflow). It names the resource and action precisely, though it does not explicitly differentiate from sibling tools like cost_query or stats.

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 any exclusions or prerequisites. It mentions org_id cross-tenant filtering and G7 linkage as conditions, but these are parameter context rather than usage guidance. There is no 'use this when...' or 'not for...' statement.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does disclose that exports include a version number and HMAC signature, and that the action is logged as a corpus_export audit event, which is useful. However, it does not clarify whether the operation is read-only, whether it overwrites existing files, or any authorization requirements, leaving gaps for a tool with no annotation safety profile.

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

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

The description is a single dense sentence that efficiently conveys a large amount of technical detail. It is front-loaded with the main purpose ('训练语料导出三件套') and uses dashes and parentheses to list components, but the run-on structure reduces readability. It is concise but could benefit from clearer separation of the three components.

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 exporting multiple components, the description provides a strong high-level overview but lacks information on default behaviors (e.g., what happens with scope='default'), output format, or error handling. Since there is no output schema, the description does not explain return values, and terms like '六源聚合' and '脱敏' are mentioned without elaboration, leaving some ambiguity for an agent.

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

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

The input schema provides 100% description coverage for all four parameters, so the description does not need to add parameter details. The description adds no extra information about parameters beyond what the schema already offers, which meets the baseline of 3 but does not exceed it.

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: exporting a training corpus composed of three components (rules, FDE methodology, labeled audit samples), with specific technical details like 27 numbered positions, verifiers three-bucket list, and six-source aggregation. This distinguishes it from siblings such as workflow_export or train_submit, which handle different export/training workflows.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions, prerequisites, or context that would help an agent choose it. It merely describes what the tool exports, leaving the decision entirely to the agent's inference.

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

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

With no annotations, the description carries the transparency burden. It does disclose that the operation is a query and enumerates the audit output categories, which is useful. It does not mention response format or side effects, though the verb '查询' suggests read-only 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 a single dense, front-loaded sentence with no filler. Every phrase contributes meaning, and the structure makes the tool's scope immediately understandable.

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 query with optional parameters and no output schema, the description sufficiently names the returned data categories (budget config, actual consumption, WARN records). It lacks explicit guidance on when to prefer it over related siblings, but that gap is already captured in the usage guidelines dimension.

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%, so the schema already documents both parameters. The description's mention of budget configuration and token/cost over-limit records loosely aligns with maxCostPerDay and maxTokensPerRun, but it adds no parameter-specific 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 states a clear action ('查询' / query) and a specific resource: cost audit, covering budget configuration, per-agent token/cost consumption, and WARN-level over-limit records. This is specific and informative, though it does not explicitly distinguish itself from sibling tools like stats or train_budget.

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

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

The phrase '查询成本审计' implies this is the go-to tool for reading cost and budget audit data, so the intended usage is inferable. However, it provides no explicit when-to-use guidance, no exclusions, and no pointer to alternative tools such as train_budget or run_audit.

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?

There are no annotations, so the description carries the full burden. It states that configuration is derived, but does not disclose side effects, whether anything is persisted, what happens when target_dir is provided, or what the returned configuration looks like. The schema partially covers persistence, but the description itself leaves mutation semantics unclear.

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 dense sentence with no filler. It front-loads the core purpose and lists the output components, making it easy to scan and understand.

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 only two parameters and full schema coverage, the description plus schema covers the essentials. However, with no output schema and no annotations, the absence of output format or side-effect details leaves noticeable gaps for an agent that needs to predict the behavior fully.

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%, so both parameters are already documented. The description only reinforces the purpose of 'requirement' and does not add meaningful detail beyond the schema, so the baseline of 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's action: automatically deriving an Agent configuration from a one-sentence requirement, and specifies the derived components (role + domain rules + think + knowledge). It is specific and informative, though it does not explicitly differentiate itself from sibling creation/composition tools.

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

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

The phrase '一句话需求' implies the tool is for concise, natural-language requirements, but there is no explicit guidance on when to use this tool versus alternatives such as create_entity or sofagent_compose. No exclusions or alternative routing are given.

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

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

The description implies a write operation but does not disclose whether updates overwrite content, how existing concepts are identified, or what side effects occur. With no annotations, the description carries the burden and only covers the bare upsert intent.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is concise, though slightly too terse to convey important upsert semantics.

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

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

For a tool with no annotations and no output schema, the description leaves key context missing: how update is triggered, whether content is replaced wholesale, and what the tool returns. The tool may be simple, but an agent cannot fully infer correct invocation behavior from this description alone.

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%, so name and content are already documented in the input schema. The description adds no extra parameter-level meaning, such as whether name is the unique key for updates, so it meets the baseline without exceeding it.

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 clear verb-resource pair: '创建/更新 concept 页' (create/update concept page). It differentiates from read/delete/list concept siblings by signaling mutation, though it does not explicitly name alternative tools.

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

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

No guidance is given about when to use this tool versus alternatives like create_entity, update_entity, or read_concept. It also does not explain the conditions under which a create versus an update occurs.

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 present, so the description carries the burden. It usefully discloses a pre-write audit that rejects on FAIL, but it does not explain the audit criteria, write outcome, or error 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?

One compact sentence, front-loaded with the verb/resource and followed by the key audit constraint. 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?

Adequate for invoking the tool with all four documented parameters, but leaves gaps: no output contract, no FAIL definition, and no relationship to update_entity. Given no annotations or output schema, more context would be 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 coverage is 100%, so the schema already documents all parameters. The description adds no extra parameter-level meaning beyond naming the page as the target entity.

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 a specific action ('create/update entity page') and identifies the resource. It is clear, but it does not differentiate itself from sibling update_entity despite claiming both create and update 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?

No guidance about when to use this tool versus update_entity or create_concept. The audit-before-write statement describes a behavioral guarantee, not a usage condition or alternative.

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 explicitly states the operation is read-only ('只读') and lists the output fields (PID, start time, heartbeat), disclosing what the agent can expect. It does not cover error behavior or permissions, but for a status tool this is 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?

The description is a single, front-loaded sentence with zero waste. It states the action, the resource, the output fields, and the read-only nature all at once. Every word earns its place.

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

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

For a zero-parameter, read-only status tool with no output schema, the description is complete. It tells the agent what the tool does, what it returns, and that it is safe (read-only). No additional information is required for correct invocation.

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

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

The tool has zero parameters, so the schema is trivially complete (100% coverage). Per rubric, 0 params gives a baseline of 4. The description adds no parameter-specific details because none exist, and none are needed.

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

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

The description clearly states a specific verb ('查询' - query) and resource (daemon running status), and enumerates the exact fields returned (PID, start time, heartbeat). It distinguishes itself from siblings like health_check by being daemon-specific, so an agent can tell them apart without opening the schema.

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

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

The description implies usage as a read-only status check ('只读'), but it does not explicitly state when to use this tool versus alternatives like health_check or stats, nor does it mention any exclusions. For a simple query tool this is acceptable, but there is no explicit routing 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?

在无注释的情况下，描述承担了行为披露的全部责任。它主动揭示了“分拣闸（敏感档标记）”和“合规闸（拦截违规）”的检查流程，以及“拒绝留痕进审计链”的副作用，这远超出标准行为描述，让智能体了解数据会被筛选并可能被拒绝且留下审计记录。虽然没有提及权限、异步性等，但已提供了关键行为特征。

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?

描述为一句紧凑的中文长句，信息密度高，没有冗余。它精确地概括了目的、输入类型、处理流程和副作用，结构上无浪费，符合高效表达的标准。

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?

鉴于工具参数简单（4个必填、无嵌套、有枚举）且无输出模式，描述提供了目的和流程，虽未提及返回格式或错误处理，但根据模式已足够支撑调用。缺少返回信息和并发限制细节，但复杂度较低，描述基本完整，扣一分因未提及成功/失败的状态反馈。

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?

输入模式覆盖率100%，每个参数都有描述，因此基础评分为3。描述中“按约定 schema 推送”仅对参数整体进行了暗示，但未具体说明每个参数（如kind、samples）的格式或约束，未在模式基础上增加实质语义。参数语义主要依赖模式本身。

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?

该描述用动词“推送”明确指出了操作，并明确资源是“训练语料/知识数据”，同时描述了“双闸入库”的流程，使其与兄弟工具（如搜索、调用、导出等）区分开来。它具体定义了工具是数据接送入口，而非通用操作。

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?

描述未提供任何“何时使用”、“何时不用”或替代工具的指导。虽然它明确定义了数据推送场景，但未说明与其他数据相关工具的区分条件或限制，例如哪些数据不适用此入口。这导致智能体无法明确判断是否应选择此工具而非其他。

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. The verb '查询' suggests a read-only operation, but the description does not explicitly state that it is non-mutating, does not trigger a new audit, or whether the result is a cached summary. It adds content context but lacks explicit behavioral guarantees.

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

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

The description is a single, front-loaded sentence that states the report type and key content categories in a compact parenthetical. There is no filler or redundancy, and it is appropriately sized for a one-parameter tool.

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

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

For a simple one-parameter query tool with no output schema, the description is mostly adequate. It lists the summary categories, which likely map to return fields, but it does not describe the return format (e.g., JSON object vs. text), nor clarify side effects or whether a new audit is triggered. These gaps are not critical, but they leave some ambiguity.

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

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

The single `date` parameter is fully described in the schema (today/yesterday/YYYY-MM-DD, default today), giving 100% schema_description_coverage. The tool description adds no additional parameter semantics beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb ('查询') and a precise resource ('数据主权审计报告摘要'), and enumerates the expected content (云端调用/本地执行/数据流出/敏感本地处理率). This clearly distinguishes it from sibling audit/report tools like run_audit or audit_trail by its unique data-sovereignty 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?

Usage is implied: it retrieves a data sovereignty audit summary for a given date. However, there is no explicit guidance on when to choose this over sibling tools, no prerequisites mentioned, and no alternatives or exclusions stated.

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

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

No annotations are provided, so the description carries the full burden, but it only states that this defines acceptance criteria. It does not disclose the overwrite-on-same-task_id behavior, persistence effects, validation failures, or return behavior; the overwrite detail appears only in the task_id parameter description, not in the tool description.

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

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

The description is a single front-loaded sentence with no filler, immediately identifying the action and scope. It is concise and easy to parse, though it sacrifices behavioral and usage detail.

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

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

For a mutation tool with no annotations and no output schema, the description is somewhat thin: it omits overwrite semantics (though the schema covers it), how to verify acceptance later, and what result to expect. The schema covers parameters well, but an agent still lacks enough behavioral and workflow context.

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

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

Schema description coverage is 100%, so the schema already documents task_id, criteria, and notes. The description's mention of test/build/grep-absent/schema simply restates the enum in the schema and adds no additional 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?

The description names the action ('define') and the resource ('acceptance criteria'), and lists the supported machine-checkable types (test/build/grep-absent/schema). It is not a tautology and is distinguishable from the sibling check_acceptance by the define-vs-check contrast, though it does not explicitly call out that sibling.

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 its use when a task needs machine-determinable acceptance criteria, but it gives no explicit guidance on when to use this tool versus alternatives such as check_acceptance. There is clear context, but no exclusions or explicit routing.

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

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

With no annotations provided, the description carries the full burden of warning the agent that this is a destructive operation (🔴 破坏性操作) gated by confirmed:true. It does not mention irreversibility or side effects on related content, but the core behavioral risk is clearly disclosed.

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

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

The description is very short, front-loads the action, and then delivers the critical safety condition. Every word earns its place, and the warning emoji reinforces the destructive nature without adding noise.

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 destructive tool, the description covers the object, action, and required confirmation guard. The only gap is the lack of mention of post-delete effects, irreversibility, or expected response, but this is minor given the tool's simplicity.

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

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

Schema description coverage is 100%, so both name and confirmed are already fully documented in the schema. The description echoes the confirmed requirement but adds no new parameter-level meaning beyond what the schema 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 states a specific verb and resource: '删除 concept 页' (delete concept page). This unambiguously distinguishes it from read_concept, create_concept, and delete_entity among the sibling tools, even without naming them 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?

Usage is implied: use this tool to delete a concept, and only when confirmed:true is set. However, the description does not explicitly state when not to use it or mention alternatives such as delete_entity, so it lacks clear 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 behavioral burden, and it clearly flags the operation as destructive and requires confirmed:true before execution. It does not disclose permanence, cascading effects, or reference cleanup, but the core safety hazard is prominently communicated.

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

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

One efficient sentence with the key safety warning placed immediately after the action. There is no filler or redundant text.

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 guarded delete operation, the definition provides the essential invocation context: target, destructive nature, and required confirmation. It is slightly thin on post-conditions and return behavior, but this is a minor gap at this complexity level.

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 both parameters are clearly documented: name and confirmed. The description adds emphasis on the confirmed:true precondition but no new format, default, or edge-case 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 states a specific action ('delete') and resource ('entity page'), which clearly separates it from siblings like delete_concept and create_entity/update_entity. It does not explicitly name alternatives or clarify what an 'entity page' is, so it stops short of full 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?

No when-to-use or when-not-to-use guidance is provided. It does not mention that update_entity should be used for modifications or that verification via read_entity/list_entities may be needed before deletion. The only implicit trigger is 'delete an entity', which is too weak for choosing among closely related entity 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, and it is exceptionally transparent. It discloses opt-in default behavior, declaration validation, desensitization, AES-256-GCM encryption, WAL persistence across disconnects, cursor resume with no retransmission of acked segments, audit trail, metering into worklog, and the raw-data-never-leaves-device guarantee.

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 dense arrow-flow sentence with no filler, and the most important constraints are front-loaded (device gate → declaration validation). However, unexplained abbreviations like 'G11', 'WAL', and 'ack' plus the run-on structure reduce quick 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?

For a security-sensitive mutation tool with no annotations and no output schema, it is highly complete: validation, encryption, persistence, retry behavior, audit, metering, and data residency are all covered. It does not explicitly state return/error semantics or optional-destination handling, but those are minor compared to the rich pipeline context provided.

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%, so the baseline is 3. The input schema already explains payload, category, identity, and destination; the description reinforces the pipeline (e.g., encryption before enqueue) but adds little per-parameter semantic 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 names a specific device-data uplink pipeline ('数据上行通道') and enumerates the processing chain (gate, declaration validation, desensitization, AES-256-GCM encryption, enqueue). It is reasonably distinguishable from generic siblings like data_push and device_data_query via the device/opt-in/raw-data framing, though 'G11' is unexplained and the tool's direct 'push to destination' verb is only implied.

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

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

It gives clear usage conditions: data is only uploaded when opted in, must pass the device gate and collection-declaration validation, and destination is checked against the declaration. It does not explicitly name alternatives such as data_push or router_session_push, so cross-tool routing guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries full disclosure responsibility. It transparently describes the default-deny whitelist (默认空=全拒), the desensitization pipeline that keeps sensitive fields on-device, and side effects like audit trailing and worklog metering. It also states that raw paths are not persisted, which is a meaningful behavioral guarantee.

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 dense sentence uses an arrow pipeline to front-load the purpose and then enumerate each stage. Every phrase adds value, from the gate to the audit trail, 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 read-only tool with no output schema, this description covers the key contextual elements: security gates, default-deny policy, side effects, and output shape. It could be more explicit about the exact structure of the returned content and potential failure modes, but it is substantially complete for an agent to invoke 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 schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds general context about whitelist validation and non-persistence, but it does not add specific parameter-level semantics beyond what the schema 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 opens with '设备侧数据面授权读取' (authorized read of device-side data), clearly naming the verb (read) and resource (device-side data plane). It distinguishes itself from siblings like device_data_push and data_push by framing this as a read operation with an explicit authorization pipeline.

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

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

The description gives clear context: this is the tool for authorized reads of device-side data, with a mandatory identity gate and whitelist. It does not explicitly name alternative tools or state when not to use it, but the '读取' (read) framing plus the context of audit and metering makes the intended usage unambiguous.

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 and does so well. It explicitly declares the tool as read-only ('只读'), reveals that results include last heartbeat and online status, and discloses that rejected/revoked devices are omitted from the list. This gives the agent critical behavioral expectations beyond the 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?

The description is a single compact sentence that front-loads the core purpose, then states filters, response content, an inclusion rule, and read-only nature. Every clause earns its place with no redundant 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?

For a simple optional-parameter list tool, the description covers purpose, filters, key returned fields, and the verified-device scope. It is missing details like pagination, default behavior with no filters, and response format, but the tool is simple enough that these are not critical gaps.

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

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

Schema description coverage is 100%, so the schema already documents tenant, kind, and capability filters. The description's '按租户/类型/能力过滤' adds no new semantic detail beyond what the schema provides, so the baseline score of 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 specific verb and resource: '设备清单查询' (device inventory query), and immediately scopes it with the G9 discovery surface and filter dimensions (tenant/type/capability). This clearly distinguishes it from sibling tools like device_register, device_data_query, and device_data_push, which target different operations.

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

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

The description implies when to use the tool: to query a filtered device inventory with heartbeat/online status, and it states an important exclusion rule (only verified devices appear). However, it does not explicitly contrast it with related tools like device_data_query or device_register, nor state conditions for when NOT to use it.

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

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

With no annotations provided, the description carries the full behavioral burden and does so unusually well: it discloses that identity is verified via Ed25519, that the tool is fail-closed (forged signatures are rejected), and that rejections leave audit trails (留审计). This is security-critical behavioral context beyond the schema. It does not, however, cover idempotency, caller permissions, or error behavior beyond signature forgery.

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

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

The entire description is a single dense sentence with zero filler — every clause earns its place: the operation, the security mechanism, the type constraint, and the capability purpose. The operation name is front-loaded ('设备上线注册'), with supplementary detail following in parentheticals. This is efficient, not under-specified.

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 (nested identity object, cryptographic verification, 4 parameters) and the absence of both an output schema and annotations, the description covers the operation's semantics and security model well but leaves gaps: no description of the success response or return format, no guidance on re-registration of an already-registered device, and no mention of caller authentication requirements. An agent can invoke it correctly but cannot predict what it will receive back.

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%, so the baseline is 3. The description does add some semantic context beyond the schema by explaining why capabilities are declared (for dispatcher matching) and that the identity is Ed25519-verified, but it largely echoes the schema's enum for kind and the capability list description. The added meaning is moderate, so it stays at the baseline.

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

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

The description states a specific verb+resource: '设备上线注册' (device online registration), and goes well beyond a bare label by specifying the verification mechanism (Ed25519), fail-closed behavior, device kinds, and the capability-matching purpose (派单方按能力匹配设备). This clearly distinguishes it from siblings like device_list, device_data_query, and connector_register (which targets a different resource type).

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

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

The description implies the usage scenario: register a device when it comes online, declaring capabilities so a dispatcher can match it. However, it never explicitly states when to use this tool versus alternatives (e.g., connector_register for connectors, device_list for querying) and gives no when-not-to-use guidance. The context is inferable but not explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the high-level operations already visible in the action enum and does not explain side effects, state changes, permissions, reversibility, or what happens after freeze/run operations.

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 compact sentence with a parenthetical list of operations, making it easy to scan. It contains no redundant wording, though the terse style sacrifices explanatory depth.

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

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

This is a multi-action tool with no output schema, yet the description does not explain which parameters apply to which action, expected results, log format, or success criteria. An agent would need to infer a lot from the action enum and parameter names, which is insufficient for correct invocation across all four modes.

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%, so the input schema already documents all four parameters and their meanings. The description adds no parameter-level detail beyond the schema, which is acceptable under the baseline but does not enhance understanding of operation-specific parameter requirements.

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 identifies the tool as an enterprise-specific eval suite with four concrete operations: template loading, baseline freezing, running, and log querying. This is specific enough to distinguish it from generic evaluation tools like evaluate or evaluate_output, though it does not name those siblings 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?

No guidance is provided on when to use this tool versus sibling tools such as evaluate_output, evaluate, or run_audit. The action enum implies possible uses, but the description offers no context, prerequisites, or exclusions to help an agent choose this tool over 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 provided, the description carries the full burden. It discloses that evaluation is 'isolated' and that scores range 0..100, which is useful. It also distinguishes a read-only query mode. However, it does not mention side effects, prerequisites, cost, or what happens to existing data when evaluation triggers. It is not misleading but leaves important behavioral gaps.

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

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

The description is extremely concise, just two short clauses that introduce the tool and its two modes. It is front-loaded with the primary function. While it could be slightly more informative, it is not verbose or redundant, and every word earns its place.

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

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

For a tool that triggers an evaluation and queries logs, the description is thin. It lacks context on what 'evaluation' entails, what the output structure looks like (no output schema), what logs contain, and any side effects of triggering. It also does not explain when to use query mode versus evaluation mode in practical terms. Given the complexity and absence of output schema, this is insufficient.

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 100%, so the schema already documents benchmark_id, query, and case_id. The description mentions benchmark_id and query in the context of modes, but adds no additional meaning beyond the schema. case_id is not referenced in the description, and the schema already explains its default behavior. Baseline 3 is appropriate since the schema handles semantics.

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 performs benchmark evaluation (Benchmark 评测) and mentions two modes: triggering an isolated evaluation with benchmark_id and querying logs. This is a specific verb and resource, not a tautology. However, it doesn't differentiate from siblings like evaluate_output or eval_suite, which also deal with evaluation, so it misses a point.

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

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

The description gives two usage modes (trigger evaluation vs. query logs) and notes that benchmark_id triggers evaluation, providing clear context. However, it does not explicitly mention when to prefer this tool over alternatives or any exclusions (e.g., when not to use it). It leaves differentiation to inference.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that the tool performs an evaluation against a golden set and returns a score plus failure cases, which conveys its non-mutating character reasonably well. However, it does not describe output format, side-effect guarantees, or failure-case structure.

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

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

The description is a single concise sentence that front-loads the core purpose and the expected result. Every word contributes meaning, with no filler or redundant restatement of the tool name.

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

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

For a simple tool with two optional parameters and no output schema, the description gives a reasonable high-level overview of inputs and outputs. It is not fully complete because it omits usage differentiation from sibling evaluation tools and does not clarify the return format, but it remains functional for a low-complexity 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%, so the schema already documents the two optional parameters clearly. The description does not add parameter-level detail, but the baseline of 3 is appropriate since it does not need to compensate for schema gaps.

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 a specific action—evaluating Agent output quality using a golden set—and names the key returned artifacts (score and failure cases). It is clear enough to distinguish the tool from most siblings, though it does not explicitly contrast it with similarly named evaluate or eval_suite.

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

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

No guidance is given on when this tool should be used instead of evaluate, eval_suite, or run_audit. The intended context is implied by the golden-set mention, but without explicit alternatives or exclusion conditions, an agent cannot reliably choose between overlapping evaluation tools.

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

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

The description discloses the main side effect—results are persisted to nodes.json—and names the three classification categories. However, with no annotations provided, it carries the full behavioral burden and does not clarify whether nodes.json is overwritten, appended, or requires existing state, nor does it mention permissions or reversibility.

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 compact and front-loaded with the core purpose, with no filler. But it is telegraphic and overloaded with unexplained terms such as SSOT, GUIDE §3.2, and 引擎二, which reduces readability and the clarity an agent needs.

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 two-parameter tool with a fully documented input schema, the description conveys the high-level input-to-output flow and names the output artifact. However, there is no output schema, and the description does not explain the resulting nodes.json structure, what happens to input nodes, or how the classification labels are attached, leaving meaningful 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?

The input schema already documents all parameters with 100% description coverage, so the baseline is 3. The description adds process context by explaining that the three boolean questions drive classification and that decomposition/executor mapping follows, but it provides no field-level syntax or format details 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 function: it classifies nodes using the FDE three-question judgment, produces automation decisions, decomposes work units, maps executors, and writes results to nodes.json. It does not explicitly distinguish itself from sibling FDE tools such as fde_interview or fde_deploy, relying instead on 'engine two' jargon, so it falls just short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. It does not state prerequisites, ordering in the FDE pipeline, or conditions that would make another sibling tool more appropriate. The 'engine two' reference is too vague to help an 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, the description carries the behavioral burden. It discloses that this tool produces a 'draft' and only handles workflow generation, which implies a non-destructive, non-final output. However, it does not explicitly state whether anything is persisted, what side effects exist, or what the response will contain.

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

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

The description is a single front-loaded sentence with a parenthetical that carries the critical routing information. Every phrase earns its place, though it relies on domain jargon like '五要素' and '六引擎'.

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 gives enough to understand the tool's role in the FDE pipeline and to route ontology work elsewhere, but it leaves gaps: the five elements are not specified, the output shape is not described, and there is no mention of side effects or session constraints beyond the schema. It is minimally viable but not fully complete for an agent unfamiliar with the domain.

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%, so the baseline is 3. The description adds the 'five elements' framing and the workflow/ontology routing, but it does not define the five elements or add detail beyond what the schema already says about the action enum and session object. It adds some context but does not substantially enrich 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?

The description clearly states the tool's verb and resource: it generates a workflow.yml draft from 'five elements' and explicitly scopes itself to workflow-only. It also names fde_derive as the entry point for ontology derivation, distinguishing this tool from a close sibling.

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 this tool is workflow-only and that ontology derivation should go through fde_derive, giving the agent a direct when-to-use / when-not-to-use rule. This is exactly the kind of alternative routing that helps an agent choose the right sibling.

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 must carry the full burden. It discloses a key behavior: only produces an artifact, does not activate, and retains human review for activation. It also mentions format compatibility with fde_compose. However, it doesn't disclose side effects like overwriting existing files, idempotency, or prerequisites. It lacks a complete behavioral profile.

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

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

One concise sentence that front-loads the core purpose and then provides essential boundaries (artifact only, activation path). Every phrase adds value with no fluff. The structure is efficient and well-organized.

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

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

The tool has 4 parameters, 3 required, with a nested nodes structure, and no output schema. The description states the output file path and format compatibility with fde_compose, which helps. However, it doesn't explain the expected return value, error conditions, or the meaning of '三层交付物' in relation to the nodes parameter. It is adequate for an agent familiar with the FDE domain but has gaps for a general agent.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add any parameter-specific meaning beyond the schema. It mentions '三层交付物' but does not map it to the nodes parameter or explain how parameters influence the output. No compensation for the schema's already clear 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 states a specific action: 'FDE workflow 组装部署' (assembly deployment of FDE workflow), and specifies the deliverable as deployments/<name>.yml, with the same format as fde_compose. It also distinguishes from activation tools by stating it only produces artifacts, not activation. This clearly differentiates it from siblings like workflow_submit and activate_workflow.

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 activation goes through workflow_submit + activate_workflow, telling the agent when not to use this tool. However, it doesn't explicitly contrast with fde_compose, only mentions format similarity. It gives clear context for the activation boundary but lacks a direct 'use this instead of X when...' statement.

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

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

With no annotations, the description carries the full burden. It discloses that it produces a machine draft requiring human confirmation and that it may emit a needsFullOntology prompt above a threshold. It also indicates that import is handled separately by ontology_import, implying no direct persist side effect. However, it does not specify the exact output format, whether the tool is read-only/write, or any permission/rate-limit context, leaving notable gaps.

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

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

The description is a single, dense sentence that packs purpose, input, output, a workflow note, and a conditional. It is front-loaded with the main action and avoids fluff. The semicolon-separated structure is compact yet logically ordered, though a slightly more structured format 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 complexity (4 params, a nested array, no output schema), the description is incomplete. It states the output is a YAML draft and mentions the needsFullOntology threshold, but it does not describe the structure of the YAML (entities/concepts/relations fields), how the prompt is returned, or how the output should be handled when passed to ontology_import. The agent would need additional inference to correctly process the tool's return value.

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

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

The schema has 100% description coverage, so the baseline is 3. The description's reference to '五要素' (five elements) and '访谈' (interview) maps to the elements and questions fields in the nodes array, but it adds little beyond what the schema already describes. It provides no additional nuance for enterprise_id or workflow_name.

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

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

The description states a specific action (ontology derivation) and resource (from five elements + interview to entity/concept/relation YAML draft). It identifies itself as 'engine four' in the FDE family, which distinguishes it from siblings like fde_interview, fde_classify, fde_distill, fde_deploy, and mentions the downstream ontology_import step, clarifying its role in the pipeline. However, it does not explicitly name a sibling tool to contrast with, so a perfect score is not warranted.

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: it is used when you have interview data and five-elements to produce a YAML draft for manual review before ontology_import. It also mentions a conditional (prompting needsFullOntology when exceeding 10 entities or 5 nodes). However, it does not explicitly state when to use this tool instead of other FDE engines, nor does it provide exclusions or alternative conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully discloses the primary write side-effect (archiving three artifacts to deliverables/ with a README index), which is meaningful for a generation tool. However, it leaves gaps: no overwrite semantics, no statement of prerequisites or predecessor steps in the pipeline, and no indication of what the tool returns (no output schema exists).

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 dense sentence with zero filler words, but it is poorly structured for agent parsing: it leads with the obscure '引擎五' numbering before any explanatory content, and packs the three output layers into nested parentheticals separated by slashes and colons. The most decision-relevant signal ('跑通'=run after success) is buried mid-sentence. Compact but not 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?

The description thoroughly specifies the output layers and archive location, which is substantial context for a tool with no annotations and no output schema. But it fails to establish this tool's position in the FDE engine sequence among its siblings (fde_interview, fde_classify, fde_quantify, fde_derive, fde_deploy, fde_compose) — an agent cannot reliably infer ordering or prerequisites from the description alone.

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 100% — every parameter including nested element fields has a description, so the baseline is 3. The description's '沉淀节点' phrasing maps to the nodes parameter, but the schema itself already says the nodes are '沉淀节点（与 fde_interview 同构）'. The description adds no syntax, format, or behavioral detail beyond what the schema already documents for either parameter.

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

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

The description states a clear verb+resource: 'generate FDE three-layer deliverables' and enumerates the exact output artifacts (document-layer manual, skill-layer template, runtime-layer yaml) plus the archive target (deliverables/ with README index). However, it relies on heavy domain jargon ('引擎五/六', 'Skill 层') and never names a sibling to differentiate from, leaning entirely on the engine-numbering scheme rather than explicit contrast.

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

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

Usage context is implied rather than stated: '跑通过程沉淀' implies it runs after a process has been successfully run through, and '引擎六组装用' says the output feeds engine six. But it never explicitly says when to use this versus fde_classify, fde_derive, or fde_deploy, and the input-relationship hint to fde_interview ('与 fde_interview 同构') lives only in the schema, not in the description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses important side effects: idempotent overwrite/merge by nodeId, automatic recomputation of the enterprise portrait, and non-persistence when prompts_only=true. It does not cover auth, rate limits, error behavior, or the normal-mode return payload, but the core mutation behavior is transparent.

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

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

The description is one dense sentence that front-loads the main purpose and then packs in modes and side effects with no filler. It is efficient, though the heavy use of domain shorthand like '五要素' and '三问' may require prior familiarity with the guide.

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

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

For a tool with no output schema and no annotations, the description covers persistence, idempotent merging, profile recalculation, and the prompts_only branch. However, it does not state what a successful normal-mode call returns, what preconditions apply (e.g., enterprise_id must already exist), or how this tool fits with the many sibling FDE tools. These gaps leave moderate uncertainty for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description maps the five elements and three questions to the schema's nested objects and adds that prompts_only returns six scripts, but most parameter meaning is already present in the input schema. The added value is modest because the schema already describes the idempotent node_id key and the prompts_only no-persistence behavior.

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 opens with a specific verb-and-resource statement—'FDE 访谈结构化落盘'—and explains the core behavior: node-wise five-element collection, idempotent merge by nodeId, and automatic enterprise profile recalculation. It also distinguishes the prompts_only mode clearly. However, it does not explicitly differentiate the tool from sibling tools such as fde_compose or fde_classify, so the distinction is implied rather than explicit.

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

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

The description gives clear usage context: normal mode persists interview nodes, while prompts_only=true returns pre-interview follow-up scripts and skips persistence. It also explains multi-round append behavior as idempotent by nodeId, which tells the agent it can safely call repeatedly. It stops short of naming alternative tools or stating when not to use this tool, so it is not a 5.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It discloses a file write side effect (quantification.json), a conditional behavior (auto-associating labels when engine two has run), and the exact calculation formula. It does not cover all possible side effects, but it provides meaningful behavioral transparency beyond a simple verb.

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 dense single sentence, front-loaded with the core purpose and followed by formula, output, and conditional behavior. It contains no fluff, though the heavy technical density could be slightly clearer with more explicit segmentation.

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 computation tool with full parameter schema coverage and no output schema, the description is fairly complete: it states inputs, formula, output artifact, and an important conditional label-association behavior. It does not describe the return payload, but the tool's primary artifact is the file it writes, which is disclosed.

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%, so the baseline is 3. The description adds value by explaining how parameters relate: annual_salary multiplies takeover_ratio, and one_time_investment enters the ROI denominator with a +1 guard. This goes beyond the schema's individual field 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 states a specific computation and output goal: quantify FDE four fields, compute annual savings via a salary × takeover-ratio formula, and sort by ROI. It distinguishes itself from siblings by labeling itself as engine three and explicitly tying its formula to train_report, so an agent can tell it apart.

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 clearly positions the tool in a pipeline ('engine three') and notes a precondition: if engine two has already run, diagnosis labels are automatically associated. It does not explicitly name alternatives or when-not-to-use conditions, but the sequential context gives clear enough 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 must carry the full burden of behavioral disclosure. It only states that the tool reads entries, but does not mention side effects (e.g., whether it is read-only), return format, permissions, or any limitations. This is a minimal disclosure for a tool with zero annotation support.

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, short sentence that is front-loaded with the core purpose. It contains zero wasted words and is appropriately concise for a simple read operation.

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

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

For a tool with one optional parameter, the description is minimally sufficient but incomplete. It does not describe the return format or any pagination behavior, and it does not clarify the relationship to the sibling tool 'read_think_md'. Given the absence of an output schema and annotations, more context would be expected to ensure correct usage.

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

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

The input schema covers 100% of the parameters, including a description for 'count'. The tool description adds no additional meaning beyond the schema, so the baseline of 3 applies. There is no extra context about parameter usage or constraints.

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

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

The description clearly states the verb '读取' (read) and the resource 'think.md 的最新反思条目' (latest reflection entries from think.md). It specifies what the tool does. However, it does not differentiate from the sibling tool 'read_think_md', which appears to have a similar purpose, so it misses the opportunity to distinguish itself.

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

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

The description gives no guidance on when to use this tool versus alternatives like read_think_md or write_think. It does not state conditions for selection or any exclusions, leaving the agent to infer usage from the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't reveal whether the check is read-only, what side effects might occur, whether it requires special permissions, or what the response format looks like. Since it's a health check, it's likely non-destructive, but that's not stated, and there's no mention of any output structure.

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

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

The description is a single, concise sentence that front-loads the core purpose and lists the covered areas. There is no fluff or redundant wording. However, it is so brief that it sacrifices substantive detail for brevity, but as a conciseness measure, it earns a 4 for efficiency.

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

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

Given the tool has no annotations, no output schema, and only two optional parameters, the description is insufficient for an agent to fully understand how to use it correctly. It doesn't explain the difference between doctor and verify modes, when the platform parameter is needed, or what the health check returns. The description is minimal and leaves too much to inference.

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

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

The schema description coverage is 100%, meaning both parameters (mode and platform) are already described in the schema. The tool description adds nothing about parameter meaning or usage beyond what's in the schema. Per the baseline for high coverage, a score of 3 is appropriate because the schema handles the parameter semantics without needing the description to compensate.

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 ('运行环境健康检查' - run environment health check) and enumerates the specific areas it covers (environment, config, data directory, Hook, dependencies). This is a specific verb+resource statement. While it doesn't explicitly differentiate from siblings like train_doctor or daemon_status, the scope is sufficiently distinct that an agent can likely infer its 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 provides no guidance on when to use this tool versus alternatives, and doesn't explain the different modes (doctor vs verify) or the platform parameter's role. An agent has to rely on the schema to understand the modes, but there's no contextual clue about when one mode is preferred over the other or when this tool is the right choice compared to other health-related 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?

With no annotations, the description carries the behavioral burden. It discloses that this is a decision-submitting action on a pending checkpoint and lists the three possible outcomes. However, it does not explain the downstream effects of each decision, whether the action is reversible, or what 'aborted' semantically implies, leaving meaningful 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?

A single front-loaded sentence states the action, the target state, and the allowed decisions with no redundant wording. Every part 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?

The tool is low-complexity and the schema covers all parameters, so the description is adequate for basic invocation. However, with no output schema and no annotations, it omits what happens after a decision is submitted, whether the decision is final, and any failure or prerequisite conditions beyond 'pending'.

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%, so the parameters are already well documented in the input schema. The description adds only the overall HITL context and reinforces the decision enum, but does not materially deepen understanding of checkpoint_id, decision, or comment 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 states a specific verb and resource: submit a decision for a HITL checkpoint, and enumerates the allowed decisions (approve/reject/aborted). This clearly distinguishes it from sibling tools, none of which overlap with HITL checkpoint resolution.

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 scopes the tool to '挂起等人工确认的 checkpoint' (pending checkpoints awaiting human confirmation), which gives a clear condition for when to use it. It does not explicitly name alternatives or exclusion cases, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context by specifying the exact scope (built-in + enterprise SubAgent), but it does not explicitly state that the operation is read-only, describe the return format, or mention any permissions or side effects.

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

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

The description is a single, focused sentence with no wasted words. It conveys the action, resource, and scope efficiently and is easy for an agent to parse quickly.

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

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

For a zero-parameter, no-output-schema list operation, the description is complete enough to invoke correctly. It names the resource and the relevant subcategories, and there are no required inputs or complex behavioral details left 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?

The tool has zero parameters, so the schema already fully defines the inputs. The description does not need to explain parameter semantics, and it adds no unnecessary parameter-related detail.

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

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

The description uses a specific verb '列出' (list) and a clear resource '已注册的 Agent', and it adds scope by distinguishing built-in agents from enterprise SubAgents. This differentiates it from sibling list tools like list_capabilities, list_entities, and list_concepts based on the resource type, though it does not explicitly name any sibling.

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 usage guidance is provided. The description does not state when to prefer this tool over alternatives such as list_capabilities or list_rules, nor does it mention any conditions, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full behavioral burden. It clearly conveys a read-only, side-effect-free list operation and states the contents of the returned 'capability map' as tools and resources. The 'complete' qualifier sets the expectation that the result is exhaustive, which is useful 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 a single, well-structured sentence with the core action and resource front-loaded, followed by the usage context after an em dash. Every element earns its place with no redundant wording.

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, simple list tool, the description is adequately complete: it states what is returned and when to call it. Without an output schema, slightly more detail about the return structure could be added, but the phrase '完整能力清单' already communicates the expected result well enough.

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

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

The tool has zero parameters, so the schema fully covers parameter semantics and the description has no obligation to explain inputs. Baseline 4 applies because there is nothing for the description to add regarding 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 states a specific verb and resource: it returns the complete capability list of tools and resources. The parenthetical '(tools + resources)' precisely defines the scope and differentiates it from sibling list tools like list_entities or list_agents.

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 a clear usage context: 'Agent 首次连上时' (when the agent first connects). This gives the agent a concrete trigger for calling the tool. It does not name exclusions or alternatives, but no sibling appears to perform capability discovery, so the guidance is sufficient.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states that it lists all concepts and does not mention return format, ordering, pagination, scope limits, or whether any side effects are possible. It is not misleading, but it is very thin.

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

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

The description is a single clear sentence with no filler or redundancy, and the core action is front-loaded. It is appropriately concise for a simple tool, though it is sparse enough that it cannot earn a 5.

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 explain what the agent can expect from the call. It does not describe the return value, whether results are complete in one response, or how this tool differs from related list/read tools. For a simple no-parameter tool it is close to adequate, but the missing return and distinction details leave notable 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?

The tool has zero parameters and an empty schema, so parameter semantics are trivially complete. The description adds nothing about parameters, but none exist; this matches the baseline 4 for a no-parameter tool.

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

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

The description states a specific verb ('列出'/'list') and a resource ('concept'), and '所有'/'all' clarifies the scope as a full listing. It is distinguishable from siblings like read_concept or list_entities by the combination of verb and resource, though it does not explicitly name or contrast 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 provides no guidance on when to use this tool versus alternatives such as read_concept for a single concept or list_entities for entities. The intended usage is only implied by the verb and resource, with no exclusions or alternative routing.

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 must carry the transparency burden. It only states that entities are listed and an optional domain filter exists; it does not disclose pagination, result limits, ordering, permissions, read-only status, or response format.

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 one short sentence with no wasted words and the main action is front-loaded. It is appropriately concise for a simple tool, though it could include slightly more operational context without becoming verbose.

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

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

For a list tool with no output schema and no annotations, the description is incomplete. It leaves the agent without knowledge of return structure, any constraints on the domain parameter, or how many entities might be returned, which is needed for confident 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 description coverage is 100% for the single 'domain' parameter, and the description adds no information beyond what the schema already says. It does not explain allowed domain values, matching behavior, or how filtering interacts with the result set, so value over schema is minimal.

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 ('list') and resource ('entity') with an optional domain filter, making the core purpose clear. It does not explicitly differentiate from sibling list tools like list_concepts or list_agents, but the resource type makes the distinction implicit.

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

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

No guidance is given on when to use this tool over read_entity (for a single entity) or other list_* tools for different resource types. There are no alternatives, exclusions, or prerequisites 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?

Annotations are absent, so the description carries the full burden. It explicitly states '只读' (read-only) and '不暴露实现' (does not expose implementation), which adds useful behavioral context. However, it does not mention permissions, return format, or any side effects, so it is only partially transparent.

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

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

The description is a single, compact sentence that front-loads the action and includes the key scoping note. 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?

For a simple read-only list with one optional parameter, the description is close to sufficient. But without an output schema or any mention of what the returned rules look like, and lacking usage differentiation from siblings, it leaves some gaps in context.

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

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

Schema description coverage is 100% – the `type` parameter is fully described in the schema with an enum and default. The tool description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description clearly states 'List all audit rules' – a specific verb and resource. It adds a parenthetical read-only note, but does not explicitly distinguish itself from sibling tools like run_audit or audit_trail, so it falls just 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?

No guidance is provided about when to use this tool versus alternatives. With many sibling audit-related tools (run_audit, audit_file, audit_trail), the description leaves the agent to infer when listing rules is appropriate.

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?

无注释，描述仅提及触发循环和查询，未披露副作用（如循环是否修改状态）、权限要求、是否只读等。对于没有注释的工具，行为披露严重不足。

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?

描述简短，用分号分隔两种模式，结构清晰。但过于简略，未解释循环细节或查询返回内容，虽然简洁但信息量不足。

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?

无输出模式，描述未说明返回值或循环终止条件，对于复杂调试循环工具，信息明显不足，代理无法预知调用后果。

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?

输入模式覆盖率100%，描述未提供超出架构的参数语义。基于规则，基线为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?

描述明确说明工具用于触发调试循环（activate→run→judge→fix）或查询记录，具体指出了两种模式。虽然未与兄弟工具区分，但功能独特且动词明确，足以让代理理解其用途。

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?

描述给出了使用条件：传task触发循环，不传则查询记录。但未提及何时不应使用此工具，也未列出替代方案，仅隐含了使用场景，缺少明确排除。

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 are absent, so the description carries the full disclosure burden. It only says 'register' and does not mention persistence, duplicate-name behavior, hash verification, validation failure, or reversibility. For a mutating registry tool this is a meaningful gap.

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

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

The description is a single front-loaded sentence with no wasted words, and the parenthetical 'name+endpoint+model' is useful shorthand. The leading '模型注册' repeats the tool name, but it does not materially harm clarity.

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

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

This is a complex tool with 10 parameters, a nested profile object, conditional requirements, and no annotations or output schema. The one-line description does not cover side effects, success/failure behavior, duplicate-name outcomes, or verify_hash implications, leaving an agent under-informed for a mutating registration operation.

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

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

Schema description coverage is 100%, and each parameter already has detailed descriptions, so the baseline is 3. The description adds no real semantic value beyond the schema; its mention of name+endpoint+model is redundant shorthand.

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 action ('注册' / register) and resource ('trained model endpoint'), and even summarizes the core fields as name+endpoint+model. It is distinguishable from model_unregister and model_switch by its verb, though it does not explicitly name those 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?

The phrase 'trained model' implies the tool should be used after training, but there is no explicit guidance about when to use it vs alternatives like model_switch or model_unregister. No when-not-to-use conditions or lifecycle context 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?

The description carries the full burden since no annotations exist. It usefully discloses the grayscale vs full promotion behavior and the mandatory human review at 100, but it does not mention state-change risk, reversibility, the human_confirmed hang condition, or event-trail behavior—all significant for a production model switch.

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

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

One compact sentence with the core semantics front-loaded; every phrase carries meaning and nothing is wasted. It is well-sized for the task.

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 7-parameter mutating tool with no annotations and no output schema, the description plus rich schema covers parameter meaning but leaves out the switch-flow lifecycle (e.g., pending human review, rollback semantics, event logging implied by comment). It is adequate but has clear 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 100%, so the schema already documents all 7 parameters. The description adds a little context by linking percent to grayscale vs full human review, but no supplementary meaning beyond the schema; 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 identifies a specific operation—switching the active model by lane/gear—and states the core percent semantics (grayscale below 100, full promotion with mandatory human review at 100). It does not explicitly contrast with sibling tools like model_register or model_unregister, so it stops short of full sibling 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?

No explicit when-to-use guidance or alternatives are given; the agent must infer from the action enum. There is no exclusion such as 'for model registration use model_register', so guidance is effectively absent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that retirement is recoverable and requires human confirmation, which are important traits. However, it does not mention the action enum (retire/restore), the effect of human_confirmed=false (pending state), or any other side effects or permissions. It adds some value but is not comprehensive.

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

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

The description is a single, efficient sentence that front-loads the purpose and key behaviors. It is appropriately concise with no wasted words, though it could potentially include a bit more contextual detail without becoming verbose.

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

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

For a tool with four parameters all documented in the schema, the description covers the most critical behavioral nuances: recoverability and mandatory human review. It does not explicitly mention the action parameter or comment usage, but these are already in the schema. Given the lack of output schema, the description is reasonably complete for an agent to understand the tool's core 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?

The schema description coverage is 100%, so all four parameters are fully documented in the schema. The description does not add any extra meaning beyond what the schema provides, so it neither enhances nor detracts from the baseline 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's purpose: it retires a model ('模型退役'), specifies that the retirement is recoverable ('可恢复'), and mandates human review ('强制人审'). This is a specific verb+resource with key behavioral attributes, distinguishing it from siblings like model_register or model_switch without ambiguity.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The only implicit hint is the mandatory human review, which implies a governance context, but it does not name sibling tools or conditions 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 of behavioral disclosure. It states that a summary is pushed to the current session, but it does not explain side effects such as whether the message persists, whether an active session is required, or whether any response is returned. This is a meaningful gap for a tool that mutates session state.

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

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

The description is a single compact sentence with the main action and target front-loaded, followed by a short parenthetical purpose. Every word earns its place; there is no filler, redundancy, or unnecessary background.

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?

All five parameters are fully documented in the schema, and no output schema exists, so return values need not be explained. However, the description lacks usage context and behavioral side-effect disclosure, which are relevant for an agent deciding whether and how to call this tool. It is minimally 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?

Schema description coverage is 100%, so the input schema already documents every parameter, including enums, defaults, and the meaning of summary/details/think_ref. The description adds no parameter-level information beyond what the schema provides, so the baseline of 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 identifies the action ('推送' / push), the object ('审计结果摘要' / audit result summary), and the target ('当前 session'). It is specific enough to distinguish this from audit-execution siblings like run_audit and audit_file. However, it does not explicitly contrast with related notification/persistence tools, so it stops 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?

No explicit guidance is given about when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The parenthetical '确保结果可见' implies a purpose, but the description never states that this should follow run_audit or that write_think might be an alternative for persistent reflection.

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

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

No annotations are provided, so the description must carry the full burden. It mentions the output is a three-part structured prompt and that it feeds into workflow_node_add, but it does not disclose whether the tool mutates state, requires specific roles or permissions, or has side effects beyond generating text. It doesn't state that it might create a node automatically or just returns text. This lack of behavioral disclosure is a significant gap.

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

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

The description is extremely concise: one sentence, front-loaded with the core purpose and a hint of the output structure. It avoids redundancy and includes a valuable integration detail (workflow_node_add). Every word contributes to understanding the tool's 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 tool's moderate complexity (3 params, 1 required, simple schema), the description is mostly sufficient for calling it. However, it lacks behavioral transparency (output format details, whether it modifies workflow state) and does not explain the exact integration with workflow_node_add (e.g., does it return a node object that is then passed?). Since no output schema exists, the description should clarify what the returned data looks like.

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%, so the schema already documents each parameter. The description adds context about the output structure (three parts) and the role field's effect on tool surface, which slightly enhances understanding, but it doesn't provide additional syntax or format details beyond the schema. Baseline 3 is appropriate since schema is sufficient.

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 purpose: it's a prompt generator that converts a job description into a three-part structure (responsibilities/boundaries/tool surface). It names the resource (job description input) and the verb (generate), and the domain is clear from the title. It also distinguishes it from siblings by referencing the workflow integration, though not explicitly naming alternatives.

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

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

The description implies usage: given a role description, generate a prompt and then integrate via workflow_node_add. It does not explicitly state when not to use or name alternatives, but the context of siblings (workflow CRUD tools) makes it clear this is for prompt generation, not for direct workflow editing. The lack of explicit exclusions is a minor gap.

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

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

With no annotations, the description carries the full burden. It does disclose that the operation validates and audits before registering, which is useful, but it does not explain persistence effects, failure behavior, permission requirements, or what happens if validation fails. Significant behavioral context is missing.

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

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

The description is a single compact sentence that front-loads the core purpose and pipeline. It wastes no words, though it is somewhat terse and could include one or two more meaningful details without becoming verbose.

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

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

Given no annotations and no output schema, the description leaves the agent uncertain about return values, error cases, audit outputs, and edge behaviors like duplicate submission. The three parameters are documented in the schema, but the overall operation is under-explained for an agent to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only paraphrases the payload structure already in the schema and adds no new parameter semantics such as validation rules, JSON format details, or how comment and agent_id affect the audit trail.

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 identifies a clear verb ('注入' / submit and register), a specific resource (ontology entities, concepts, relations), and the processing pipeline (validation + audit then registration). It is distinguishable from siblings like validate_ontology and create_entity by scope and action, though it does not explicitly name alternatives.

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

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

No when-to-use guidance is provided. The description does not state when an agent should choose this tool over validate_ontology, create_entity, create_concept, or update_entity, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description must disclose side effects and behavior. It mentions 'optimize' and 'generate suggestions', but does not clarify whether it modifies the file in place, whether changes are reversible, whether it requires special permissions, or what the safety scanning/check_only behavior is. This ambiguity is significant for a tool that likely mutates files by default.

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

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

The description is a single concise sentence with no filler, and it front-loads the core action and target. It could be slightly more informative without becoming wordy, but as written it is appropriately sized for a simple tool.

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

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

Given no annotations and no output schema, the description carries a heavier burden. It does not explain the return value format, whether the tool modifies files, how check_only changes behavior, or how this tool relates to siblings like 'refine'. The information provided is enough to guess intent but not enough to invoke the tool safely and 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 100%, so both parameters are already documented in the input schema. The description itself adds no extra parameter-level meaning beyond what the schema provides, so the baseline of 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 verb ('optimize') and the resource ('specified Skill file'), and adds that it generates optimization suggestions. It is easy to understand what the tool does, though it does not explicitly differentiate itself from related siblings such as 'refine' or 'audit_file'.

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

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

The description provides no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. The only implied usage is the generic 'when you want to optimize a Skill file', but there is no explicit routing or context to help an agent select it confidently among the many 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the tool returns passed and details, but it does not clarify whether failures throw exceptions or simply return passed=false, whether the operation has side effects, or whether any waiting/retry behavior occurs.

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 compact sentence with no filler. It front-loads the main purpose and includes the key return information, making it easy for an agent to scan quickly.

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

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

For a simple one-parameter tool, the description covers basic invocation and return values. However, with no output schema and no annotations, it should also clarify what 'details' contains and how failures are represented, which are not addressed.

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%, so the schema already documents the condition parameter with examples. The description adds a little context by mentioning text/element existence, but it does not provide additional syntax, allowed values, or formatting guidance 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: perform assertions on a page for text/element existence and return passed status with details. It uses a specific verb and resource and is easily distinguished from sibling tools like playwright_navigate, playwright_click, and playwright_screenshot.

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 intended usage is implied: use after navigating to a page to verify text or element presence. However, there is no explicit guidance about when to use this tool versus alternatives or any preconditions such as 'a page must be loaded first.'

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